diff --git a/.run/P36/agents/ov_SC04_011__func_80130D48/body.c b/.run/P36/agents/ov_SC04_011__func_80130D48/body.c
index a9c9db6f61..48f7943aab 100644
--- a/.run/P36/agents/ov_SC04_011__func_80130D48/body.c
+++ b/.run/P36/agents/ov_SC04_011__func_80130D48/body.c
@@ -1,139 +1,128 @@
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
     u8 *p = D_80078E78;
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        ret = (void *)func_8012C658(0x33, 0, pa);
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
     } else {
-        switch (s1v & 0xFFFF0000) {
+        switch (val & 0xFFFF0000) {
         case 0x10000: {
             u32 x = D_80078EB4;
             u32 y = D_80078EB2;
             u32 b;
             u32 a;
 
-            s1v = 0;
+            val = 0;
             if (x == y) {
-                s1v = 0xC;
+                val = 0xC;
             } else if ((y >> 1) >= x) {
-                s1v = 3;
+                val = 3;
             }
 
             b = *(u16 *)(p + 0x40);
             a = *(u16 *)(p + 0x3E);
             if (b == a) {
-                s1v += 0x18;
+                val += 0x18;
             } else if ((a >> 1) >= b) {
-                s1v += 6;
+                val += 6;
             }
-            { s32 v1; s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8019083C; tbl = (s16 *)(bp + v1); }
+            tbl = D_8019083C + val;
 
             r = rand() % 100;
-            cnt = 0;
-        loop27:
-            if (r >= *tbl) {
-                cnt += 1;
-                tbl += 1;
-                if (cnt < 3) {
-                    goto loop27;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
 
-            s1v = 0;
-            switch (cnt) {
+            val = 0;
+            switch (i) {
             case 0:
                 tbl = D_8019089C;
-                s1v = 0x31;
+                val = 0x31;
                 break;
             case 1: {
                 s32 mx = *(u16 *)(p + 0x3A);
                 s32 cur = *(u16 *)(p + 0x3C);
                 if (((mx * 7) / 10) >= cur) {
-                    s1v = 4;
+                    val = 4;
                     if ((mx / 2) >= cur) {
-                        s1v = 8;
+                        val = 8;
                         if ((mx / 5) >= cur) {
-                            s1v = 0xC;
+                            val = 0xC;
                         }
                     }
                 }
-                { s32 v1; s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801908A4; tbl = (s16 *)(bp + v1); }
-                s1v = 0x32;
+                tbl = D_801908A4 + val;
+                val = 0x32;
                 break;
             }
             case 2: {
                 s32 mx = *(u16 *)(p + 0x3E);
                 s32 cur = *(u16 *)(p + 0x40);
                 if (((mx * 7) / 10) >= cur) {
-                    s1v = 4;
+                    val = 4;
                     if ((mx / 2) >= cur) {
-                        s1v = 8;
+                        val = 8;
                         if ((mx / 5) >= cur) {
-                            s1v = 0xC;
+                            val = 0xC;
                         }
                     }
                 }
-                { s32 v1; s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801908C4; tbl = (s16 *)(bp + v1); }
-                s1v = 0x33;
+                tbl = D_801908C4 + val;
+                val = 0x33;
                 break;
             }
             }
 
             r = rand() % 100;
-            call_a1 = 0;
-        loop50:
-            if (r >= *tbl) {
-                call_a1 += 1;
-                tbl += 1;
-                if (call_a1 < 4) {
-                    goto loop50;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            ret = (void *)func_8012C658(s1v, call_a1, pa);
+            ret = func_8012C658(val, j, arg0);
             break;
         }
         case 0x20000:
-            ret = (void *)func_8012C658(0x33, 0, pa);
+            ret = func_8012C658(0x33, 0, arg0);
             break;
         case 0x30000:
-            ret = (void *)func_8012C658(0x31, 0, pa);
+            ret = func_8012C658(0x31, 0, arg0);
             break;
         case 0x40000:
-            ret = (void *)func_8012C658(0x32, 0, pa);
+            ret = func_8012C658(0x32, 0, arg0);
             break;
         case 0x50000:
-            ret = (void *)func_8012C658(0x33, 0, pa);
+            ret = func_8012C658(0x33, 0, arg0);
             break;
         case 0x60000: {
             s32 rr = rand() & 0xFF;
+            s32 id;
             tbl = D_8019080C;
-            if (rr >= *tbl) {
-                do {
-                    tbl += 3;
-                } while (rr >= *tbl);
+            while (rr >= *tbl) {
+                tbl += 3;
             }
-            call_a0 = tbl[1];
+            id = tbl[1];
             if (*(u16 *)(p + 0x40) < 4U) {
-                call_a0 = 0x33;
+                id = 0x33;
             }
-            ret = (void *)func_8012C658(call_a0, tbl[2], pa);
+            ret = func_8012C658(id, tbl[2], arg0);
             break;
         }
         case 0x70000:
-            ret = (void *)func_8012C658(0x27B, 0, pa);
+            ret = func_8012C658(0x27B, 0, arg0);
             break;
         default:
             return;
@@ -141,6 +130,6 @@ void func_80130D48(s32 arg0)
     }
 
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
diff --git a/.run/P36/agents/ov_SC04_011__func_80130D48/mechanism.md b/.run/P36/agents/ov_SC04_011__func_80130D48/mechanism.md
new file mode 100644
index 0000000000..432a39e3e0
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_80130D48/mechanism.md
@@ -0,0 +1,85 @@
+# func_80130D48 (ov_SC04_011_jr_8012ACE0.c), T7 agent c6, S103
+
+**Result: score 0, no levers left.** The function is byte-identical to the target, relocations included
+(`objdump -drz` of the function diffs empty), and the whole scratch object `scratch/final.o` has the same `.text`
+disassembly and the same `.rodata`/`.data` as the baseline object (md5 equal). No register pin, no asm, no volatile added,
+no invented zero term. `body.c` is the final text.
+
+## (a) The residual in one sentence
+A pure two-register swap, 266 against 266 instructions, nothing missing: the parameter `pa` (arg0) sat in `$s3` and the
+struct pointer `p = D_80078E78` sat in `$s2`. The target has them the other way round. The 3-instruction "insert" at the head
+is only the prologue scheduler moving the save of whichever register receives `a0` (`sw s2; move s2,a0` in the target,
+`sw s3; move s3,a0` in mine). It goes away once the swap is fixed.
+
+## (b) The pass and the decision (read, then proved on bytes)
+- **Global allocation order**, `global.c:594-607` `allocno_compare`: priority = `floor_log2(refs)*refs/live*10000`,
+  highest first, and ties go to the lower allocno number. Both pseudos cross calls, so `find_reg` gives them callee-saved
+  registers in allocation order. `tbl` took `$s0` and `val` took `$s1`, so whichever of the two came next took `$s2`.
+- Allocation table of the lever-free body (`tools/alloc_table.py free`, dumps in `scratch/dumps_free/`):
+  `p` = r75, 8 refs / 198 live, **priority 1212.1**. `pa` = r74, 4 refs / 208 live, **priority 384.6**.
+  The order line ends `... 75 74`, so `p` is allocated first and gets `$s2`.
+- Doing the arithmetic rules out every small move. Declaration order cannot change the result because the priorities are
+  distinct and priority is compared first (`global.c:602`). To get `pa` above 1212, `pa` needs 9 or more refs at about
+  208 live, or `p` needs 3 or fewer refs. `p`'s seven base-register uses are all in the target bytes, so the refs had to
+  come to `pa`.
+- **The fingerprint that gave the source shape** was in the target's tail, not in the residual hunks. Six case stubs are
+  `j 6448; li a0,K`, landing on a common `move a1,zero; jal func_8012C658; move a2,s2`. The two computed cases jump to
+  `644c`, which is the middle of that sequence and skips the `move a1,zero`. Compilers emit this shape when the shared
+  suffixes of N separate call sequences are merged by **cross-jumping**: `jump.c:1969` (the simplejump case) and
+  `find_cross_jump` at `jump.c:2371`. It runs only in the post-reload jump pass, `toplev.c:3142`
+  `jump_optimize (insns, 1, 1, 0)`, which comes after global_alloc (`toplev.c:3077`) and after sched2 (`toplev.c:3117`).
+  So the original had **one call per case**, and global allocation saw every one of them: `global.c:421`
+  `allocno_n_refs[allocno] += reg_n_refs[i]` counts arg0 once per call site.
+- **Proved on dumps** (`scratch/dumps_c9/`, the final body): arg0 is now r72, **11 refs** (1 set + 2 loads + 8 call args)
+  / 208 live, **priority 1586.5**, which is above `p` (r74, still 1212.1). The order line ends `... 72 123 150 74`.
+  The `.greg` and `.sched2` dumps still hold **8** `func_8012C658` call_insns and the final `.s` holds **1**, so the merge
+  happens in jump2 after allocation, as the reading predicted.
+
+## (c) The source moves that closed it
+1. (The whole close.) De-merge the shared call tail. Replace the `call_a0 = K; call_a1 = 0; goto do_call;` sites and
+   the `do_call:` label with one call per case, `ret = func_8012C658(K, 0, arg0); break;`, and an `if (... == 0xB) ...
+   else switch` in place of the early goto. The null check on `ret` stays shared after the switch. This scored 0 on its
+   **first `--try`** (`scratch/c1.c`).
+2. Readability changes, each re-proved at 0:
+   - the lever-residue blocks `{ s32 v1; s8 *bp; ... }` become `tbl = D_8019083C + val;` (c2);
+   - `ret` becomes `s32`, the callee's real return type, which removes the casts (c3);
+   - the `pa = arg0` copy is dropped (c4);
+   - `if (rr >= *tbl) do tbl += 3; while (...)` becomes `while (rr >= *tbl) tbl += 3;` (c5);
+   - the two goto counting loops become `for (i = 0; i < 3; i++, tbl++) { if (r < *tbl) break; }` (c8);
+   - the variables are renamed (`s1v`→`val`, `cnt`→`i`, `call_a1`→`j`), and `id` is scoped to case 0x60000 (c9 = body.c).
+
+## (d) Generator proposal
+When a callee-saved swap involves a pseudo that is a call argument at a **shared `goto do_call` tail** (the target shows
+`j L; li a0,K` stubs, and some of them jump into the MIDDLE of a common call sequence), emit one call per goto site
+(`args...; goto do_call;` becomes `ret = f(args); break;`) and let jump2's cross-jump re-merge them at zero byte cost. This
+multiplies the shared argument's refs in `global.c:421`, which raises its `allocno_compare` priority. A tool can check the
+move by arithmetic before compiling: new refs = old refs + (call sites − 1), and the priority must pass the rival
+allocno's.
+
+The same fingerprint says the tree's `do_call:` gotos were never the original shape. Any residual-free function with a
+`goto do_call`-style tail is a candidate for this readability rewrite.
+
+## (e) What did not work, or was not needed
+- The mechanical search (history.txt: 6 runs, up to 2342 compiles, best 18) could not reach this. Every move it has
+  (R7 block/do-while, R8 temp/hoist/base, R9 swap-stmts) keeps the single call. By the arithmetic above, no
+  single-statement move can make up a 384 → 1212 priority gap.
+- `while (r >= *tbl) { ...; if (++i >= 3) break; }` (c6) and a `do { if (r < *tbl) break; ... } while (i < 3)` (c7)
+  both scored 56 (274 instructions against 266, 8 more instructions). The `for` form (c8) and the original goto form both
+  score 0.
+- Not tried: the pins on `$3` that `sites.txt` marks NEEDED. The lever-free start never showed a `$v1`/`$v0` residual,
+  so there was nothing to fix there.
+
+## (f) Where the method fell short / notes for the next agent
+- The residual and the allocation table said exactly **what** was wrong (priority 384.6 against 1212.1) and proved that no
+  small move could close it. They could not say **how** the original earned the refs. The answer was in the target's
+  whole-function dump (METHOD step 1): cross-jump stubs jumping into the middle of a shared call. The hunk view never
+  shows the tail because the tail is identical. **Proposed method step:** when the table shows a priority gap too large for
+  a local move, read the target for merge fingerprints (cross-jump stubs, delay-slot constants before a common `jal`)
+  and count how many source sites the merged code stands for.
+- `neighbours.txt` recorded this function's LEVERS in English ("pin pa=$s2 p=$s3") but not a mechanism. A lever
+  recipe is not a crack.
+- Side finding (naming evidence, not used): `D_80078EB2` and `D_80078EB4` are `D_80078E78 + 0x3A` and `+ 0x3C`, the same
+  struct that `p` walks (case 1 reads `p + 0x3A`/`p + 0x3C`). In case 0x10000 the target reaches them by absolute
+  `lui/lhu` rather than through `$s3`, so the original also wrote those two reads as direct global accesses.
+
+Paths: `body.c`, `mechanism.md`, candidates `scratch/c1.c`…`scratch/c9.c`, dumps `scratch/dumps_free/`, `scratch/dumps_c9/`.
diff --git a/.run/P36/agents/ov_SC04_011__func_80134A74/body.c b/.run/P36/agents/ov_SC04_011__func_80134A74/body.c
index 6079055ca5..7d49b32a4b 100644
--- a/.run/P36/agents/ov_SC04_011__func_80134A74/body.c
+++ b/.run/P36/agents/ov_SC04_011__func_80134A74/body.c
@@ -4,7 +4,7 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern s32 func_80134C20(s32, s32, s32, s32);
 
     Map_80133AB0 *map = (Map_80133AB0 *)param_4;
-    u32 X, Y, cell;
+    u32 X, Y;
     u16 Xc, Yc;
     u16 k, off, cnt;
     u16 *cp, *lst;
@@ -17,24 +17,23 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
 
     X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
     Xc = X;
-    if (!((X & 0xffff) < map->w))
+    if ((u16)X >= map->w)
         return 0;
     Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
     Yc = Y;
-    if (!((Y & 0xffff) < map->h))
+    if ((u16)Y >= map->h)
         return 0;
 
     p0C = map->p0C;
     p10 = map->p10;
     p18 = map->p18;
     p1C = map->p1C;
-    cell = Yc * map->w + Xc;
-    k = cell * 2;
+    k = (Yc * map->w + Xc) * 2;
     cp = (u16 *)(k * 2 + (u32)map->cells);
     p14 = map->p14;
     off = cp[0];
     cnt = cp[1];
-    lst = (u16 *)(p14 + off + cnt * 2) - 1;
+    lst = (u16 *)(p14 + off) + cnt - 1;
 
     while (cnt-- != 0) {
         raw = *lst;
@@ -42,10 +41,11 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
         harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
+            lst--;
         } else {
             s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
         }
-        lst--;
         if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
             D_801EDA40 = *(u16 *)s0;
             return 1;
diff --git a/.run/P36/agents/ov_SC04_011__func_80134A74/mechanism.md b/.run/P36/agents/ov_SC04_011__func_80134A74/mechanism.md
new file mode 100644
index 0000000000..3d98437cf9
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_80134A74/mechanism.md
@@ -0,0 +1,100 @@
+# func_80134A74 (ov_SC04_011) — mechanism
+
+**Final score 0** (from 30; the mechanical search's best was 17). `mine 107 ins, target 107`. The candidate object's
+words equal the tree object's word for word (`scratch/mine.words` vs `scratch/target.words`, `cmp` clean). I calibrated
+the harness first: `body_tree.c` scores 0 through the same `--try`. The text is `PACK/body.c`. It has no register pin, no
+`asm`, no `volatile` and no zero term (the free body's two `+ 0` terms are gone).
+
+## (a) The residual in one sentence
+
+It had two parts. First a COUNT gap: the lever-free body was **five instructions short**. cse had folded away three
+register copies (`move t1,a1` = X kept whole, `move a0,v0` = Y kept whole, `move a0,v0` = the flag bit), the two
+re-masks at the cell computation that go with them, and the counter's old-value copy (`move v0,sN`). Second, once the
+count was right, a **callee-saved swap**: the list pointer took `$s2` and the counter `$s1`, where the target has the
+list pointer in `$s1` and the counter in `$s2`.
+
+## (b) The passes and decisions, `file:line`
+
+1. **The copies (COUNT) are the same cse decision agent c4 read on the sibling func_80133AB0.** I did not re-derive them.
+   The coordinator relayed them and the bytes agree. MIPS gcc 2.7.2 has no `PROMOTE_MODE` (`config/mips/mips.h:2622` is
+   only a comment), so a `u16` local is a HImode pseudo. A copy into it is a SUBREG move, which the `(set REG0 REG1)`
+   fold (`cse.c:7440-7474`, gate `:7455`) does not touch. Its later use expands as `zero_extend:SI`, which cse cannot
+   match against the bounds test's `(and:SI x 65535)`. A `u16` post-decrement has no `addhi3`, so it goes through
+   `expr.c:8645` `copy_to_reg`. Proved on bytes: `scratch/n2.c` (widths only) already shows all three copies and both
+   re-masks.
+2. **The swap is `global.c:596-610` `allocno_compare`**, with priority = `floor_log2(refs) * refs / live_length * 10000`.
+   The references are weighted by loop depth (`flow.c:2067/2315/2501/2711`, `reg_n_refs[regno] += loop_depth`). I read
+   it with `tools/alloc_table.py` on my own dumps (`scratch/dump.sh`, from the `--try` scratch TU):
+   - before (`scratch/n4.c`, score 7): order `89 92 86 77 …`. The counter r86 has refs 11, live 42, so 3·11/42 =
+     **7857**. The list pointer r88 has refs 7, live 38, so 2·7/38 = **3684**. The counter is allocated first and takes
+     `$s1`.
+   - after (`body.c`): order `89 92 88 86 …`. The list pointer r88 now has refs 11, live 39, so 3·11/39 = **8461**. The
+     counter r86 has refs 11, live 43, so **7674**. The list pointer is allocated first and takes `$s1`, which is the
+     target.
+
+   The pointer's references rose from 7 to 11 because its decrement `lst--` is written in BOTH arms of the
+   `if (hib == 0)`. Each in-loop set+use counts 2×2. The two copies still exist at global-alloc time: cross-jumping
+   runs only in the last `jump_optimize (insns, 1, 1, 0)`, after reload and sched2 (`toplev.c:3139-3142`; the
+   `cross_jump` arm is `jump.c:1923/1969`, `find_cross_jump` `jump.c:2371`). That pass merges the two identical tails
+   into the single `addiu s1,s1,-2` at the join, so the extra reference changes the allocation and costs zero bytes.
+   The dump confirms the allocation arithmetic; the bytes confirm the final merge.
+3. **The layout** (the `return 1` block before the loop, reached by a backward `bnez`) needs no goto. With plain early
+   returns and a `while` loop, loop.c's `find_and_verify_loops` moves the exit block out of the loop on its own
+   (`scratch/n3.c` and later all show the target's `j`/`j` pair). I did not open `loop.c` for this, so it is inferred
+   from bytes only.
+
+## (c) The source moves (one line each), from `body_free.c`
+
+1. Replace the goto layout with two early `return 0`s and `while (cnt-- != 0) { … if (call) { D_801EDA40 = *s0; return 1; } }`.
+   `param_4` is typed as the TU's existing `Map_80133AB0 *` (same field offsets, same struct as sibling func_80133AB0).
+2. Widths: `u16 Xc = X`, `u16 Yc = Y` (copies of the unmasked `u32` results; the bounds tests read `(u16)X` / `(u16)Y`),
+   `u16 harg = hib` (the flag copy), and `u16 cnt` with `while (cnt-- != 0)`. These give the five missing instructions.
+3. Hoist the five struct fields the loop reads (`p0C, p10, p18, p1C` before the cell computation, `p14` after it) into
+   locals. Left as `map->…` they stay inside the loop because of the call (`scratch/n3.c`, score 60). Hoisted, the
+   score is 7 (`scratch/n4.c`) and only the s1/s2 swap is left.
+4. **Write `lst--` in each arm of the `if (hib == 0)` / `else`** instead of once after it. This takes 7 to **0**
+   (`scratch/v_b.c`).
+
+The following changes were checked and are byte-neutral: `(u16)X >= map->w` instead of `!((X & 0xffff) < map->w)`,
+`(u16 *)(p14 + off) + cnt - 1` instead of `(u16 *)(p14 + off + cnt * 2) - 1`, and folding `cell` into
+`k = (Yc * map->w + Xc) * 2`. `cp = &map->cells[k]` is NOT neutral (it scores 13), so the byte-address form stays.
+
+## (d) Generator proposal
+
+**R-dupe-tail (`delever.split_tail_ref`)**: when a REG-callee swap between two pseudos that both cross a call is left,
+and `alloc_table` shows the loser's priority falling short because of a small `refs` (floor_log2 bucket), look for a
+statement at the join point after an `if/else` inside the loop. Typically this is a pointer/counter step (`p--`, `p++`,
+`i++`). Duplicate it into both arms. The loop-depth-weighted refs go up by 2·depth per copy, and the post-reload
+cross-jump (`toplev.c:3142`) merges the copies back at zero byte cost. Predict first: the new priority is
+`floor_log2(refs + 2·depth) · (refs + 2·depth) / live`. Try it only if that passes the rival. This is the reverse of a
+cross-jump: the original programmer's duplicated tail is invisible in a decompiler's output, but it is visible to the
+allocator.
+
+## (e) What did not work (byte evidence)
+
+- Declaring X and Y as `u16` and comparing those variables directly (`scratch/n1.c`, score 51) produces no copies:
+  the compare and the later use are the same zero_extend, so cse shares the mask. The only difference between
+  `scratch/n1.c` and `scratch/n2.c` is the split form (`u32 X; u16 Xc = X; if ((X & 0xffff) < …)`), and that split
+  brings back both copies and both re-masks.
+- Leaving the struct fields as `map->…` in the loop (`scratch/n3.c`) scored 60: the loads were not hoisted across the call.
+- Changing the counter's shape instead of the pointer's: `u32 cnt; u16 rem; for (;;) { rem = cnt--; if (!rem) break; … }`
+  (`scratch/v_c.c`) and `u16 cnt, rem` with the same loop (`scratch/v_d.c`) both stay at 7. Both leave the counter's
+  priority above the pointer's.
+- Declaration order was not tried. The priorities (7857 vs 3684) are distinct, so `global.c:604-610` never reaches
+  its allocno-number tie-break.
+
+## (f) Where the method fell short
+
+- `tools/cc1_dumps_tu.sh` expects an `rtu_match` work directory, and its cpp line adds only the `t.c` directory to the
+  include path. A TU with a relative `#include "../shared/…"` needs `-I<the TU's own directory>` instead. I wrote
+  `scratch/dump.sh`, which dumps the `--try` scratch TU (`.run/P36/engine/score/<alias>__<fn>/`) directly. A `--dump`
+  flag on `delever_search.py --try` would remove this step for every agent.
+- `--try` writes its object to `.run/P36/engine/score/<alias>__<fn>/cand.o`. That path is not printed, so step 1 of
+  METHOD_S103 ("dump your candidate's object") costs a search. Printing the path would save it.
+- The single largest step (score 7 to 0) came from `alloc_table` arithmetic plus asking "what raises refs at zero byte
+  cost". METHOD step 4 should name the loop-depth weighting of refs (`flow.c` `+= loop_depth`) and post-reload
+  cross-jumping as the two free ways to move a priority.
+
+Proved on bytes: every score quoted above and the final word equality. Proved on dumps: the before/after priorities and
+the allocation order lines. Not re-proved by me: c4's cse and expr line numbers for the copies (relayed), and the
+loop.c placement of the exit block.
diff --git a/.run/P36/agents/ov_SC04_011__func_80135004/body.c b/.run/P36/agents/ov_SC04_011__func_80135004/body.c
index 6fdd76f497..2dc6891602 100644
--- a/.run/P36/agents/ov_SC04_011__func_80135004/body.c
+++ b/.run/P36/agents/ov_SC04_011__func_80135004/body.c
@@ -11,21 +11,21 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     s16 *pac;
     s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801909C0;
 
-    a = ((u16 *)p2)[0]; pac = D_801909BC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801909BC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801EDA30;
+    a1v = pac[0]; a2v = pac[2];
     D_801EDA40 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801EDA30)) {
     found:
         pb4 = (*(u16 * *)&D_801909C4);
         ((u16 *)p2)[0] = pb4[0];
diff --git a/.run/P36/agents/ov_SC04_011__func_80135004/mechanism.md b/.run/P36/agents/ov_SC04_011__func_80135004/mechanism.md
new file mode 100644
index 0000000000..7d29bc4542
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_80135004/mechanism.md
@@ -0,0 +1,92 @@
+# func_80135004 (src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c): T7 agent c8, S103
+
+**Result: score 0 (89/89 instructions). No pin, no asm, no added volatile, no invented term.** Checked by `--try` twice.
+The disassembly of the whole scratch object (every function, words and relocations) is identical to the tree object's,
+by `diff` of `objdump -drz` with the file-name line skipped. The coordinator still has to run the whole-object gate.
+
+Two joint moves on `body_free.c`:
+1. **Split the reused temps per group.** `u16 a, b;` reused across the x/y/z groups becomes `u16 ax, bx, ay, by, az, bz;`.
+2. **Pass `D_801EDA30` straight to the call.** The `d94` local is dropped and the call is written
+   `func_80134A74(id, a1v, a2v, D_801EDA30)`, the same spelling the body's second call already used.
+
+Each move alone: the split scores 26 (the block-scoped form in `scratch/vC.c`), the inline scores 16 (`scratch/ab3.c`),
+from a start of 26. Together they score 0.
+An equivalent form that keeps `d94` also scores 0 (`scratch/m1.c`): write `d94 = D_801EDA30;` AFTER `D_801EDA40 = 0;`.
+That form proves the mechanism of move 2 (see (b)).
+
+## (a) The residual in one sentence
+The start was one instruction long (90 vs 89) and had the pointer locals permuted: target pb0=t1, pac=a2, pb8=t0,
+b=v1, with d94 in a3. The start had pb0=v1, pb8=a3, b=t0. The extra instruction was a load-delay `nop` in group 3 that
+the target fills with `andi s1,a0,0xffff`, and the target also hoists the `D_801909C0` load above the RTL prologue.
+
+## (b) The passes and decisions (read in source; each proven on dumps in `scratch/d_*` and on bytes)
+1. **Temps reused across groups go to global allocation.** `local-alloc.c:472` admits a pseudo only when
+   `reg_n_deaths == 1`. The shared `a`/`b` die 3 times, so they appear in the `.greg` order line (`80 79 …`) and are
+   placed after every local pointer. pb0 then took v1 before b could. Split per group, each temp dies once and becomes
+   a high-priority local qty (7500/5000), so v0/v1 go to the temps first. The same finding is agent c1's, on sibling
+   func_80135168.
+2. **Where the `D_801EDA30` load lands decides a3.** With `d94 = D_801EDA30;` written before `D_801EDA40 = 0;`, the load
+   is `(set r82 (mem D_801EDA30))` and the call gets a separate copy `(set a3 r82)`. Combine cannot fold the load into
+   the copy: `can_combine_p` (`combine.c:914-917`) calls `use_crosses_set_p`, and that returns 1 for a MEM source when
+   a memory store lies between (`combine.c:10134`, `mem_last_set > from_cuid`). The store to `D_801EDA40` sits between
+   them. The pseudo load then floats late in sched1, pb0's window leaves a3 free, and local-alloc gives pb0 a3 (score 5
+   in `scratch/vD.c`).
+   With the global passed straight to the call, `calls.c:1626` expands it to a MEM, and because
+   `preserve_subexpressions_p` is false outside a loop and MIPS has no SMALL_REGISTER_CLASSES, it is not copied into a
+   pseudo (`calls.c:1652-1664`). `calls.c:1881` then emits one insn, `(set (reg:SI 7 a3) (mem D_801EDA30))`. Moving the
+   `d94` assignment after the store gives the same insn through combine, because no store is in between any more
+   (`scratch/d_m1/t.i.combine` insn 96, and in `d_vC` the two insns 79/95 stay apart).
+3. **sched1 places that hard-reg load at the start of its window.** The a3 load's only hard dependences are true deps on
+   the three `[0]` stores, which are non-`/s` MEMs. The `/s` stores at offsets 2 and 4 do not conflict with a fixed
+   non-struct load (`sched.c:817-841`). In the backward list schedule the load keeps getting "blocked" on the memory
+   unit after every other load, so it is placed last in backward order, which is right after the `pb8[0]` store (sched1
+   index 12; trace in `scratch/d_ab1/t.i.sched`). The ALU-only `id` zero-extend and the a0 argument copy fill the hazard
+   slot at T-7 instead, which pulls them out of group 3.
+4. **local-alloc (`qty_compare_1`, `local-alloc.c:1598`; `find_free_reg`, `:2073`).** Hard a3 is now live from index 12
+   to the call, so it is busy through the windows of both pb0 and pb8. Group 3's pb0-store→pb8-store gap shrank from 6
+   insns to 4 (id and the a0 copy left it), so pb8's length is 32 against pb0's 34. The priorities
+   (`scratch/../../ov_SC04_011__func_80135168/scratch/lpri.py` on `d_ab1`) are pac 12/48 = 2500, pb8 8/32 = 2500 and
+   pb0 8/34 = 2352. pac and pb8 tie, and pac wins the tie on its lower qty number. So pac takes a2 (the incoming p2 is
+   dead after `move s0,a2`), pb8 takes t0 (a3 is busy), and pb0 takes t1. That is the target. The prologue hoist of
+   `lw t1` and the `andi` filling the group-3 delay slot then come out of sched2 without further changes.
+
+## (c) The moves that closed it
+- `u16 a, b;` → `u16 ax, bx, ay, by, az, bz;`, one pair per x/y/z statement group. Per-group block-scoped
+  `{ u16 a, b; … }` also works (`scratch/w1.c`).
+- `d94 = D_801EDA30; … func_80134A74(id, a1v, a2v, d94)` → `func_80134A74(id, a1v, a2v, D_801EDA30)`. The alternative
+  is to keep `d94` but assign it after `D_801EDA40 = 0;` (`scratch/m1.c`).
+- **Not needed here:** c1's `((H16 *)&D_801EDA40)->h = 0;` member-store move. With the two moves above, the plain store
+  scores 0 (`scratch/ab1.c`), and with the store move plus the split but d94 left in place the score is 5.
+
+## (d) Generator proposal
+When a call argument is a plain global (or any MEM) that the body first loads into a local, and a memory store sits
+between that load and the call, try passing the global directly in the call, or moving the local's assignment below
+the last store. The argument then becomes a single `(set (reg argN) (mem))` insn (`calls.c:1881`, or combine once
+`combine.c:10134` no longer refuses). That insn blocks argN through the preceding stores and reshuffles local-alloc for
+every pointer live there. Score it jointly with the per-group temp split (R-split) whenever the residual is a pointer
+permutation that involves an argument register.
+
+## (e) What did not work (byte evidence, `scratch/*.c`)
+- `vA`: hoisting `d94 = D_801EDA30;` to the top of the unsplit body scores 24.
+- `vB`/`vB2`: dropping the a/b temps and re-reading `p2[i]`/`p1[i]` scores 39/41 and adds 10 instructions (the stores
+  may alias the params, so the loads are repeated).
+- `vC2`/`vD2`: the split plus d94 at the top scores 16. a3 is blocked from index 5, but that puts the d94 load into
+  group 1's pb0→pb8 gap, pb0 and pb8 tie on length 34, and pb0 wins the tie: t0/t1 are swapped, and there is an extra
+  `nop`.
+- `battery.py` (42 compiles): moving `id = …` to every slot changes nothing. Moving `d94 = …` gives only two outcomes:
+  before the `[0]` stores gives 16 (the swap), anywhere after them gives 5 (pb0 = a3), because sched1 re-floats the
+  pseudo load late.
+- `u_*.c`: an `arg0` param of type `u16` changes nothing (16/5/16).
+- `w2.c`: also inlining `pac[0]`/`pac[2]` into the call scores 4 (ORDER).
+
+## (f) Where the method fell short
+- The coordinator's relay of c1's result (the temp split) was worth a lot: it took me from 26 to 16 or 5 at once. The
+  local-qty priority script (c1's `lpri.py`) is what exposed the pb0/pb8 tie at 34/34. alloc_table's global-formula
+  priority (5000/4444) would not have shown it. The engine needs a local-alloc priority column.
+- The count gap (90 vs 89) was NOT a missing-instruction defect. It was a scheduling consequence of the register
+  permutation (a3 held by pb8 kept the d94 load out of the delay slot). "Count first" still helps, but a ±1 count gap
+  next to a register permutation should be read as schedule, not as cse.
+- The battery over statement slots showed that source position is not what decides here, because sched1 re-floats a
+  pseudo load. What decides is whether the argument reaches the call as a pseudo copy or as a direct hard-reg load.
+  The mechanical search has no move for "inline a local into its single call-argument use" or for "move a load below a
+  store". That is a new move family (see (d)).
diff --git a/.run/P36/agents/ov_SC04_011__func_80135168/body.c b/.run/P36/agents/ov_SC04_011__func_80135168/body.c
index 57d1bcd0b9..49c25727ee 100644
--- a/.run/P36/agents/ov_SC04_011__func_80135168/body.c
+++ b/.run/P36/agents/ov_SC04_011__func_80135168/body.c
@@ -1,5 +1,8 @@
 int func_80135168(u16 arg0, u16 *p1, u16 *p2)
 {
+    /* [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 §100); the whole-binary byte-gate is the arbiter. */
     extern u8 D_801909BC;
     extern u8 D_801909C0;
     extern u8 D_801909C8;
@@ -7,17 +10,17 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     s16 *pac;
     s16 *pb8;
     u16 *pb4;
-    u16 a0, b0, a1, b1, a2, b2;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801909C0);
 
-    a0 = p2[0]; pac = (*(s16 * *)&D_801909BC); pb0[0] = a0; b0 = p1[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = b0; pb8[0] = a0 - b0;
-    a1 = p2[1]; pb0[1] = a1; b1 = p1[1]; pac[1] = b1; pb8[1] = a1 - b1;
-    a2 = p2[2]; pb0[2] = a2; b2 = p1[2]; pac[2] = b2; pb8[2] = a2 - b2;
+    ax = p2[0]; pac = (*(s16 * *)&D_801909BC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801EDA30;
-    D_801EDA40 = 0;
+    ((H16 *)&D_801EDA40)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801909C4);
         p2[0] = pb4[0];
diff --git a/.run/P36/agents/ov_SC04_011__func_80135168/mechanism.md b/.run/P36/agents/ov_SC04_011__func_80135168/mechanism.md
new file mode 100644
index 0000000000..3e880770ca
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_80135168/mechanism.md
@@ -0,0 +1,93 @@
+# func_80135168 (src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c): T7 agent c1, S103
+
+**Result: score 0 (62/62 instructions). Words and relocations are identical to the tree object's function, checked by
+`diff` of `objdump -drz`. Stable over repeated `--try` runs. No pin, no asm, no added volatile, no invented term.**
+The coordinator still has to run the whole-object gate.
+
+## (a) The residual in one sentence
+Nothing is missing: both sides are 62 instructions. What differs is the register permutation of three single-block
+pointer locals and one reused temp: target pb0=t0, pac=a2, pb8=a3, b=v1; the start had pb0=v1, pac=a3, pb8=a2, b=t0.
+The target also hoists the `D_801909C0` load above the prologue, which is the 2-instruction "insert" at the head.
+
+## (b) The passes and decisions (read in gcc-2.7.2 source, then proven on dumps and bytes)
+Three decisions stack. Each one is proven on the `.lreg`/`.sched` dumps (`PACK/scratch/dumps_*`), and the combination
+is proven on bytes.
+
+1. **Which pass allocates the temp: local-alloc or global.** `local-alloc.c:472` hands a pseudo to local-alloc only when
+   `reg_basic_block >= 0 && reg_n_deaths == 1`. The start text reused one `u16 a, b` across all three x/y/z statement
+   groups, so each of them dies 3 times. That makes them GLOBAL allocnos: the start's `.greg` order line is `81 80 75`,
+   and alloc_table shows r81=b and r80=a with "dies in 3 places". Global allocation runs only after every local qty
+   already has its register, so the local pointer pb0 took v1 before b could get it, and b ended up in t0.
+   **Move 1:** give each group its own temps (`ax,bx / ay,by / az,bz`). Each now dies once, so each is a local qty with
+   priority 7500 (3 refs over 4 indices). That is higher than the pointers' priority, so the temps are placed first:
+   b→v1 and a→v0 inside each group's window. Pointer pb0 then finds v0/v1/a0/a1 busy. Proven: this alone takes the
+   score from 25 to 12. pb0=t0 and b=v1 come out right, and the head hoist comes out right too (not traced, see (f)).
+2. **The order among the three pointers (local-alloc `qty_compare_1`, `local-alloc.c:1598-1625`).** The priority is
+   `floor_log2(refs)*refs / (death-birth)`. Birth and death are `2*insn_number` after sched1 (`reg_is_set` :1970,
+   `wipe_dead_reg` :2057). `find_free_reg` (:2073) then gives each qty the lowest free hard reg over its window. After
+   move 1: pb8 = 8/30 → 2666, **pac = 12/46 → 2608**, pb0 = 8/32 → 2500. So pb8 was placed before pac and took a2, and
+   pac got a3. The target needs pac > pb8 > pb0.
+3. **Why pac lived 46 indices: sched1 dropped an anti-dependence (`sched.c:858-863`, `anti_dependence`).**
+   `a2v = pac[2]` is `MEM_IN_STRUCT_P` because its address is a top-level PLUS_EXPR (`expr.c:4570-4577`), and its
+   address varies. `D_801EDA40 = 0` is a plain scalar at a fixed address. The exception clause drops the
+   store-after-load edge, so sched1 sank the `pac[2]` load below the store and below the a0/a1 argument setups
+   (`.sched` order: 71, 80, 88, 90, **75**). That pushed pac's death from index 50 out to 56. `pac[0]` is a bare `*pac`,
+   has no `/s`, and so keeps its edge.
+   **Move 2:** store through the shared `H16` member view, `((H16 *)&D_801EDA40)->h = 0;`. A COMPONENT_REF always sets
+   `/s` (`expr.c:4888`). With both sides `/s`, the exception fails, the edge stays, and sched1 keeps the store after
+   both loads. Final `.sched` order: 71, 75, 82 (`mem/s` store), 90, 92. pac becomes 12/40 → **3000**, above pb8 2666
+   and pb0 2500, which gives pac=a2, pb8=a3, pb0=t0. This is proven on the final dump
+   (`PACK/scratch/dumps_final`, `lpri.py`).
+
+The tree's two levers encoded exactly these two decisions:
+- The `"memory"` barrier sat between the pac loads and the `D_801EDA40` store. It is the lever form of the missing
+  anti edge.
+- The three pins plus the keepalive forced the permutation that the reused temps' global allocation could not reach.
+
+## (c) The moves that closed it (they only work together)
+- **Split the reused temps per group:** `u16 a, b` becomes `u16 ax, bx, ay, by, az, bz` (one pair per x/y/z statement
+  group). Per-group block-scoped `{ u16 a, b; ... }` temps also score 0 (scratch `vF.c`).
+- **Spell the scalar-global store as a member store:** `D_801EDA40 = 0;` becomes `((H16 *)&D_801EDA40)->h = 0;`.
+  `H16` is `src/shared/engine_types.h:832` and is already used by 532 cast sites in `src/`. This is the cookbook's
+  "/s-DEP LATTICE" idiom (docs/matching-cookbook.md ~L2538) and residual_moves.md row 6 ("grant `/s`").
+
+Each move alone: the split scores 12, the store scores 20 (from 25). Together they score 0.
+
+## (d) Generator proposal
+- **Temp split:** when the residual is a register permutation, and the allocation table shows a `.greg` allocno that
+  lives in ONE block but dies in N>1 places (a temp reused across repeated statement groups), rename it apart at each
+  full redefinition (one temp per group, i.e. one per web). Each copy then dies once and becomes a local-alloc qty
+  (`local-alloc.c:472`) that is placed before the long-lived locals.
+- **/s grant on a store:** when a pointer load with a constant nonzero offset and a plain fixed scalar global store
+  both sit in the block that feeds a call, and the lever text carries a `"memory"` barrier between them, rewrite the
+  store as a member store of the width-matched shared struct (`H16` for u16/s16, `struct{s32 w;}` for 32-bit). That
+  restores the anti edge at `sched.c:858-863`. Score both moves jointly as well as singly.
+- **Likely first family member:** the sibling directly above, `func_80135004`, has the same shape and the same levers
+  (pins $9/$6/$8 plus a keepalive, same tail with `D_801EDA40 = 0`). I did not test it, to avoid the shared per-function
+  scratch object of another agent.
+
+## (e) What did not work (byte evidence, scratch/*.c)
+- `v2`: loading pb8 before `b0` in the source scores 12. sched1 re-sorts to the same order, so the lifetime is
+  unchanged.
+- `v3`/`v4`: putting the `D_801EDA40` store before the pac loads (or inlining the loads into the call args) scores 28,
+  with 60 instructions. The store floats into the third group, and pb0 and pb8 swap.
+- `v5`: swapping the `a1v`/`a2v` statements scores 12. sched1 re-sorts them.
+- `vB`: a block-scope `extern u16 D_801EDA40[];` is a COMPILE-ERROR ("conflicting types"). The file-scope
+  `extern u16 D_801EDA40;` sits just above the function. The a18 array form therefore needs a TU-level declaration
+  change and is out of scope for a body edit (types phase).
+- `vC`: the /s store alone scores 20.
+- `vD`: splitting only b scores 23. `vE`: splitting only a scores 38. Both halves are needed.
+- `vG`/`vH`: hoisting all three pointer loads to the top scores 25. It changes the lifetimes the wrong way.
+
+## (f) Where the method fell short
+- **The priority that decides here is not in the table.** `tools/alloc_table.py` prints the GLOBAL-formula priority
+  from the `.lreg` "used N times across M insns" line. For local qtys the deciding number is local-alloc's
+  `qty_compare_1` over the post-sched1 `2*insn_number` birth/death indices. The table showed pac, pb8 and pb0 all tied
+  at 5000, which hid the real order 2666 > 2608 > 2500. I wrote `PACK/scratch/lpri.py` (about 40 lines, it parses the
+  `.lreg` insn stream) to get the true order. Suggestion: add a local-qty priority column to alloc_table.
+- **The key clue was in the table but not called out.** A "dies in N places" pseudo that sits in the `.greg` order line
+  while living in one block is exactly the split case. The brief could name it.
+- **sites.txt could flag the barrier pattern.** The `barrier memory` NEEDED site placed between a pointer load and a
+  scalar-global store is a direct pointer to the /s class; the pack could say so.
+- **Not traced:** why sched2 hoists the `D_801909C0` load above the RTL prologue (`mips.md:6029` `define_expand
+  "prologue"`) once pb0 is in t0. It came for free with move 1.
diff --git a/.run/P36/agents/ov_SC04_011__func_80135A4C/body.c b/.run/P36/agents/ov_SC04_011__func_80135A4C/body.c
new file mode 100644
index 0000000000..88f7b9c67d
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_80135A4C/body.c
@@ -0,0 +1,91 @@
+s32 func_80135A4C(s32 a0, s32 a1, s32 *a2, s32 a3) {
+    typedef struct { s8 c[8]; } Blk8;
+    extern s16 func_80135480(void *param_1, s32 param_2, s16 *param_3, s16 *param_4);
+    extern s32 func_80135EB0(void *arg0, s32 arg1_);
+    extern s32 func_80136A94(s32 a0, s32 a1, s32 a2, s32 a3);
+    extern s32 func_80133AB0(s16, s16, s16, s32);
+    extern u8 D_801909BC;
+    extern u8 D_801909C0;
+    extern s16 *D_801909C4;
+    extern s16 D_801EDA3C;
+    extern u16 D_801EDA40;
+    extern s32 D_801EDA44;
+    extern s32 D_801EDA64;
+    extern u8 D_801152A8[];
+    extern u8 D_801152B0;
+
+    s32 *p;
+    s32 base;
+    s32 flag;
+    s32 acc;
+    s16 i;
+    s16 eq;
+    s32 ret;
+    s32 frame_pad[8];
+    (void)&frame_pad;
+
+    switch (((s32 (*)(void *, s32, s16 *, s16 *))func_80135480)((void *)a0, a1, (s16 *)a2, (s16 *)a3)) {
+    case 0:
+        return 0;
+    case 1:
+        base = a0 + 0x34;
+        p = (s32 *)((a1 & 0xFFFFFFF) | 0x80000000);
+        flag = 0;
+        break;
+    case 2:
+        base = a0 + 0x34;
+        p = (s32 *)((a1 & 0xFFFFFFF) | 0x80000000);
+        flag = 1;
+        break;
+    case 3:
+        base = a0 + 0x34;
+        p = (s32 *)&D_801EDA64;
+        flag = 0;
+        break;
+    case 4:
+        base = (s32)&D_801EDA44;
+        p = (s32 *)&D_801EDA64;
+        flag = 1;
+        break;
+    }
+
+    if (a1 < 0) {
+        if (func_80135EB0(p, -0x8000) != 0) {
+            goto docall;
+        }
+        for (p = (s32 *)*p; p != 0; p = (s32 *)*p) {
+            if (func_80135EB0(p, -0x8000) != 0) {
+docall:
+                func_80136A94(flag, a0, a3, base);
+                return 1;
+            }
+        }
+    } else {
+        acc = 0;
+        i = 0;
+        *(s16 *)((*(u8 **)&D_801909BC) + 6) = -0x7FFF;
+        *(s16 *)((*(u8 **)&D_801909C0) + 6) = 0x7FFF;
+        D_801EDA40 = 0;
+        D_801EDA3C = 0;
+        eq = ((V3 *)a2)->x == ((V3 *)a3)->x && ((V3 *)a2)->y == ((V3 *)a3)->y && ((V3 *)a2)->z == ((V3 *)a3)->z;
+
+        while (1) {
+            ret = func_80133AB0(0, (s16)(*(Box **)&D_801909BC)->f0, (s16)(*(Box **)&D_801909BC)->f4, (s32)p);
+            if (ret == 0) break;
+            acc |= ret;
+            if (eq != 0) break;
+            if (i++ >= 5) return 0;
+        }
+
+        if ((s16)acc != 0 || D_801EDA3C != 0) {
+            if ((*(Box **)&D_801909BC)->f6 >= -0xBCB) {
+                *(Blk8 *)D_801152A8 = *(Blk8 *)&D_801152B0;
+            }
+            (*(Box **)&D_801909C4)->f0 = (*(Box **)&D_801909C0)->f0;
+            (*(Box **)&D_801909C4)->f2 = (*(Box **)&D_801909C0)->f2;
+            (*(Box **)&D_801909C4)->f4 = (*(Box **)&D_801909C0)->f4;
+            goto docall;
+        }
+    }
+    return 0;
+}
diff --git a/.run/P36/agents/ov_SC04_011__func_80135A4C/mechanism.md b/.run/P36/agents/ov_SC04_011__func_80135A4C/mechanism.md
new file mode 100644
index 0000000000..72d447e1cb
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_80135A4C/mechanism.md
@@ -0,0 +1,136 @@
+# func_80135A4C (src/ov_SC04_011/ov_SC04_011_jr_80135A4C.c): T7 agent c10, S103
+
+**Final score 0** (from 40; the mechanical search's best was 24). `mine 181 ins, target 181`. The candidate's
+`objdump -drz` of the function (words and relocations) is identical to the tree object's (`scratch/f2.dis` /
+`scratch/last.dis` vs `scratch/target.dis`). The whole scratch object also matches the tree object: the md5 of the
+full `objdump -drz` and of `.rodata` are equal. It scored 0 on three repeated `--try` runs. The text is `PACK/body.c`. It has
+no register pin, no `asm`, no added `volatile`, no zero term and no `__builtin`. The coordinator still has to run the
+whole-object gate.
+
+## (a) The residual in one sentence
+
+This was a COUNT residual (171 vs 181), and one of its defects moved the registers. **Nine instructions were missing**
+because the second `func_80135EB0` list probe (`move a0,s0; jal; li a1; beqz v0; nop`) and the second copy of the
+walk step (`lw s0,0(s0); nop; bnez s0; move a0,s0; j; move v0,zero`) had been merged into the first probe; mine has a
+single `j d4` back into it instead. **One more was missing**: `move a0,v0`, the copy of the `z == z` store-flag result into
+`eq`. Separately, the callee-saved order of the three long-lived values was wrong: a0's copy, a3's copy and `base`
+(the tree's `s7`) sat in `s6/s7/s5` where the target has `s5/s6/s7`.
+
+## (b) The passes and the decisions
+
+1. **The merged probe is the post-reload cross-jump.** It runs in `jump_optimize (insns, 1, 1, 0)` at `toplev.c:3142`.
+   Proven by counting `func_80135EB0` call_insns per dump in `scratch/dumps_free/`: there are **2** in every dump
+   through `.sched2` and **1** in `.jump2`. So the merge happens after allocation and scheduling, in jump2. The matching
+   is `find_cross_jump` (`jump.c:2371`), called from the "other jumps to this label" loop for unconditional jumps
+   (`jump.c:1978-1990`, which walks `jump_chain`). The conditional form (`jump.c:1921-1960`) uses `jump_back_p`
+   (`jump.c:2635`). In the jump2 dump the second probe's branch is rewritten as `(set (pc) (label_ref 504))` with
+   `INSN_CODE -1`, and 504 is a new label in front of the first probe. That is the conditional-cross-jump rewrite
+   (`jump.c:1945-1950`).
+   **Why the free text merges and the final one does not (proven on the `.sched2` dumps, the input to jump2).** In the
+   free text, both exits from the walk are a `return 0` of their own. Each expands to `v0 = 0; j <ret>`, so both walk
+   steps enter jump2 as `p = *p; bnez p → loop; v0 = 0; j ret`. jump2 merges each `v0 = 0` into the function's final
+   `return 0`, which leaves two identical tails, `p = *p; bnez p → loop; j L`. It merges those, and then the probe in
+   front of them. In the final text, the walk **falls out to the function's single final `return 0`** (through the
+   `else`). The `for (p = *p; p != 0; p = *p)` exit test is rotated to the bottom (`stmt.c:2253-2330`,
+   `expand_end_loop`) and a copy is placed in front of the loop (`jump.c:2131`, `duplicate_loop_exit_test`, which is
+   allowed here because the test holds no call). So before jump2 the first exit is already a bare
+   `beqz s0 → L_ret` (`dumps_f2`, `.sched2` insn 454), while the loop's exit is `bnez s0 → top; j L_ret` (insns
+   149/201). The two tails have different shapes, `find_cross_jump` stops at the first insn (a JUMP_INSN against an
+   INSN), and nothing merges. The dumps prove these pre-jump2 shapes. **I did not trace jump2 insn by insn:** in one
+   diagnostic (`scratch/v/diag1.c`, the free walk with a short tail borrowed from func_80135888) the free walk did NOT
+   merge either. My reading of the order of jump.c's rewrites predicts that it should, so that corner is not
+   explained.
+2. **The missing `move a0,v0` is the cse SUBREG gate, the same one S103 c4 read.** With `s16 eq`, the `&&` chain
+   stores its last compare (`xor; sltiu` into an SImode temporary, r172) into eq with
+   `(set (reg/v:HI 81) (subreg:HI (reg:SI 172) 0))` (`dumps_r3/fn.cse` insn 457). The source is a SUBREG, so the
+   `(set REG0 REG1)` fold (`cse.c:7440-7474`, gate `:7455`) does not retarget the `sltiu`, and the copy survives as
+   `move a0,v0`. The loop test's `(sign_extend:SI eq)` (cse insns 315/316) comes out of the loop as a copy,
+   `(set (reg:SI 132) (subreg:SI (reg/v:HI 81) 0))`, which is combine insn 464, before `NOTE_INSN_LOOP_BEG`, and
+   becomes `move s3,a0`. So the target's `sltiu v0; move a0,v0; move s3,a0` is exactly that. I read the hoist as loop.c's
+   invariant motion and the loss of `sll/sra` as combine's `nonzero_bits` (eq is 0/1). I did not open loop.c or
+   combine.c for this, so that part is inferred from the dumps. In the free text `s32 t = zt` is a same-mode SI copy,
+   and cse folds it, which puts `sltiu a0` directly into t.
+3. **The register order is `global.c` `allocno_compare` (`:596-610`, priority = `floor_log2(refs)*refs/live*10000`,
+   ties to the lower allocno).** With the first two moves in place (`dumps_e8`, score 19), the order line ends
+   `... 78 77 72 75`: base r77 has 6 refs over 101 = **1188.1**, a0 r72 has 6/103 = **1165.0**, a3 r75 has
+   6/104 = **1153.8**. So base took `s5`, a0 took `s6` and a3 took `s7`. The target needs 72 > 75 > 77.
+   **The fix passes the function's own parameters through to `func_80135480`**. The tree's text called it through
+   `(s32 (*)(void))`, with no arguments. The call then carries `(set a0 r72) … (set a3 r75)` (visible in `.greg`), so at
+   global-alloc time r72 and r75 each gain a reference: a0 has 7/107 = **1308.4**, a3 has 7/108 = **1296.3**, and
+   base has 6/105 = **1142.9**. The order line ends `... 78 72 75 77`, giving s4/s5/s6/s7 = flag/a0/a3/base, which is
+   the target (`dumps_f2`, `alloc_table.py f2`). **These moves cost zero bytes.** The post-reload jump pass deletes a
+   register copy whose destination already holds the value (`jump.c:425-462`, `find_equiv_reg`). `a0` still holds
+   the incoming argument that `move s5,a0` just copied, so `move a0,s5` goes away. The `.sched2` dump has 6
+   `(set (reg:SI 4 a0)` and `.jump2` has 5. The arguments exist for the allocator and are gone in the bytes. The cast to
+   `s32 (*)(void *, s32, s16 *, s16 *)` stays because the declared `s16` return would add `sll/sra` on the switch value
+   (`scratch/v/f1.c`, score 9). It is the exact spelling the sibling func_80135888 uses (see (f)).
+
+## (c) The source moves (one line each, from `body_free.c`)
+
+1. **List walk:** `if (EB0(p) != 0) goto docall; for (p = *p; p != 0; p = *p) { if (EB0(p) != 0) { docall: …; return 1; } }`
+   ends with no `return 0` of its own. The a1 ≥ 0 path moves into the `else`, and both fall to the function's one final
+   `return 0`. (A `p = *p; if (p != 0) do { … } while (p != 0);` spelling also scores 0: `scratch/v/s_do.c`.)
+2. **`s16 eq` and `eq = a2->x == a3->x && a2->y == a3->y && a2->z == a3->z;`** replace the `t`/`zt` block.
+3. **Pass the parameters to the dispatcher:** `((s32 (*)(void *, s32, s16 *, s16 *))func_80135480)((void *)a0, a1, (s16 *)a2, (s16 *)a3)`.
+
+Readability, each re-proved at 0: `goto out` becomes `break`, and the `old = i; i = i + 1` block becomes
+`if (i++ >= 5) return 0;` (`r1`). `acc = 0` moves into the `else` (`r2`). `s7` is renamed `base`, the sibling's name
+(`r3` = `body.c`).
+
+Scores for each move (byte-measured, `scratch/v/`): args alone 40 → 21 (`s_args`), walk alone 40 → 27 (`v1f`),
+eq alone 40 → 36 (`s_eq`). Walk + eq: 19 (`e8`). Walk + args: 8 (`s_walkargs`). All three: **0**. With move 1
+in place, eq variants: `s32 eq` with the `&&` chain scores 54 (`e1`; with an SI destination the chain expands
+differently), `s16 t` inside the old block scores 19 (`e4`), `u8 t` scores 20 (`e5`), and `s16/u16 zt` score 27 (`e2/e3`,
+because the copy that has to survive is t's, not zt's).
+
+## (d) Generator proposals
+
+- **R-args-passthrough:** use this when a register residual swaps callee-saved holders, one of the losing allocnos is
+  an incoming parameter, and the function calls a callee whose declared prototype takes (some of) the caller's own
+  parameters in the same argument registers, but the text calls it with fewer or none (a `(T (*)(void))` cast).
+  Pass the parameters through. Each adds one ref to the parameter's pseudo at global-alloc time, and jump2's
+  `find_equiv_reg` deletes the moves (`jump.c:425-462`), so it costs zero bytes. Check it by arithmetic first:
+  the new priority is `floor_log2(refs+1)*(refs+1)/live'`.
+- **R-shared-return:** use this when a COUNT residual shows the target with a peeled first probe plus a second copy of
+  the loop step, and mine has a `j` back into the first probe. Stop giving the loop's exits their own `return K`:
+  let them fall out (if/else) to the function's final `return K`, and write the walk as a `for` loop whose step is also
+  its init. The first exit then reaches jump2 already as a bare branch to the shared return label, so no tail matches.
+  Test: `func_80135EB0`-style call count per dump (2 through sched2 and 1 at jump2 means cross-jump).
+- **R20 for `&&` values:** use this when the target keeps `sltiu vX; move aY,vX` for a boolean built from an `&&`/`if`
+  chain. Declare the destination `s16` (not `s32`, and not the inner temporary) and assign the whole `&&` expression.
+
+## (e) What did not work (byte evidence, `scratch/v/`)
+
+- `a1.c`: the sibling's walk (`if (EB0) goto docall; p = *p; if (!p) return 0; do {…} while (p); return 0;`) with
+  this function's tail scores 40, still merged. The walk's own `return 0` is the defect, not the loop form.
+- `diag0.c`: `-0x8000` → `0` (the sibling's argument), still merged. The constant is not the difference.
+- `t1.c`: giving the out-path its own `func_80136A94(...); return 1;` scores 60. Both merges still happen.
+- `f1.c`: passing the args through the declared `s16` prototype scores 9, from the extra `sll/sra` on the switch value.
+- `s_noeq.c`: the final text with `s32 eq` scores 54.
+
+## (f) Where the method fell short
+
+- **neighbours.txt was empty** (this function's own header is a carried-decl marker). The answer was in a
+  **different TU file**: `src/ov_SC04_011/ov_SC04_011_jr_80135888.c` func_80135888, closed today. It has the same
+  switch, the same `base = p0 + 0x34`, the same list walk with `goto hit` into a do-while, and the pass-through
+  `((s32 (*)(void *, s32, s16 *, s16 *))func_80135480)(arg0, arg1, arg2, arg3)` call. The brief says "grep the TU
+  for a global your body touches", but here the sibling sits in another file. **Suggest: `neighbours.txt` should
+  include lever-free bodies in ANY file of the same overlay that call the same callee** (`grep -l func_80135EB0
+  src/<overlay>/*.c`). That grep, not the residual, is what pointed at the args move.
+- The pass-through args are invisible in the bytes (jump2 deletes them), so neither the residual nor the target
+  disassembly can show them. A sibling's text or the alloc-table arithmetic is the only way in. **The alloc table plus
+  "what adds a ref at zero byte cost" (S103 c5/c6 named the loop-depth weighting and cross-jumped duplicates) should
+  also list "arguments passed in the register that already holds them".**
+- METHOD step 3's cross-jump bullet offers the `extern alias __asm__("SYM")` escape for cross-jump merges. Here the
+  real fix was a control-flow spelling (the shared return), and the alias was never needed. I would list "does each
+  merged exit return on its own? let it fall to the function's return" before the alias.
+- Tooling: my `scratch/dump.sh` needs `-dR` for `.sched2` (without it the pre-jump2 state is not dumped). The first
+  version of my `t.sh` resolved a relative candidate path from the repo root, and one diagnostic was mis-scored
+  before I noticed. It now takes `realpath`.
+
+## Paths
+
+- `PACK/body.c`: the score-0 text (= `scratch/v/r3.c`).
+- `PACK/mechanism.md`: this file.
+- `PACK/scratch/`: `t.sh` (score + candidate disassembly), `dump.sh` (cc1 dumps of the last `--try` TU), `v/`
+  (every candidate), `dumps_{free,a1,d1,e8,f2,r3,sib}/`, `target.dis`, `free.dis`, `f2.dis`.
diff --git a/.run/P36/agents/ov_SC04_011__func_8013CF68/body.c b/.run/P36/agents/ov_SC04_011__func_8013CF68/body.c
new file mode 100644
index 0000000000..624984ee28
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_8013CF68/body.c
@@ -0,0 +1,43 @@
+void func_8013CF68()
+{
+    extern void func_80028620();
+    extern u8 D_800A5E94[];
+    extern s32 D_800A5E8C;
+    extern s32 D_800A5E90;
+    extern u8 D_800A5E95;
+    extern u8 D_800A5E96;
+    extern u8 D_801F1558;
+    extern u8 D_801F1559;
+    extern u8 D_801F155A;
+    extern u8 D_801F155B;
+    extern u8 D_801F155C;
+    extern u8 D_801F155D;
+    extern u8 D_801F155E;
+    extern u8 D_801F155F;
+    extern u8 D_801F1560;
+
+    u8 t0, t1, t2;
+    u8 *base;
+
+    do { base = D_800A5E94; } while (0);
+
+*(s32 *)(D_800A5E94 - 0xC) = 0;
+    t0 = D_801F1558; t1 = D_801F1559; t2 = D_801F155A;
+    D_800A5E8C = 0x1E;
+    D_800A5E90 = 0;
+    base[0] = t0; D_800A5E95 = t1; D_800A5E96 = t2;
+    func_80028620(0, D_800A5E94 - 0xC);
+
+    *(s32 *)(D_800A5E94 + 4) = 0; *(s32 *)(D_800A5E94 + 8) = 7;
+    t0 = D_801F155B; t1 = D_801F155C; t2 = D_801F155D;
+    *(s32 *)(D_800A5E94 + 0xC) = 0x14;
+    D_800A5E94[0x10] = t0; D_800A5E94[0x11] = t1; D_800A5E94[0x12] = t2;
+    func_80028620(1, D_800A5E94 + 4);
+
+    *(s32 *)(D_800A5E94 + 0x14) = 0;
+    t0 = D_801F155E; t1 = D_801F155F; t2 = D_801F1560;
+    *(s32 *)(D_800A5E94 + 0x18) = -0x12;
+    *(s32 *)(D_800A5E94 + 0x1C) = 0;
+    D_800A5E94[0x20] = t0; D_800A5E94[0x21] = t1; D_800A5E94[0x22] = t2;
+    func_80028620(2, D_800A5E94 + 0x14);
+}
diff --git a/.run/P36/agents/ov_SC04_011__func_80140958/body.c b/.run/P36/agents/ov_SC04_011__func_80140958/body.c
new file mode 100644
index 0000000000..876d567d31
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_80140958/body.c
@@ -0,0 +1,133 @@
+s32 *func_80140958(ot, i, n)
+s32 *ot;
+s16 i;
+s16 n;
+{
+
+    extern s16 D_8011514E;
+    extern u8 D_80115158[];
+    extern Hw4 D_8011516A[];
+    extern Prim4 D_8019129C[];
+    extern Prim4 *D_80191390[];
+    extern u8 D_80115143;
+    extern Prim4 D_8019124C[];
+    extern s16 D_801917AC[];
+    extern s16 D_801917BC[];
+    extern u16 D_801912CC;
+    extern u16 D_801912CE;
+  extern Env_80140958 D_800AE7BC[];
+  Prim4 *p;
+  s16 t;
+  s32 c3;
+u16 *a;
+u16 *b;
+u16 *c;
+u16 *e;
+u16 *pb;
+u32 m24;
+u32 mhi;
+  if (i < n)
+  {
+    c3 = 3;
+    a = &D_80115110;
+    b = a + 5;
+    c = a + 3;
+    e = &D_801912CE;
+    do
+    {
+      if (((a[0] == 0) && (a[1] != c3)) && (a[1] < 6))
+      {
+        if (i == a[5])
+        {
+          ot = func_80140D68(ot, &D_8019124C[i], i, D_801917AC[a[3] & 7], 0);
+        }
+      }
+      else
+      {
+        p = D_80191390[i];
+        if (((p != 0) && (i == b[0])) && (i != 6))
+        {
+          if ((i == 2) && ((*((s16 *) (b + 7))) != 0))
+          {
+            p = D_8019129C;
+          }
+          if (i != c3)
+          {
+            t = ((s32 (*)(s16)) func_8014168C)(i) * 2;
+          }
+          else
+          {
+            t = ((*((u8 *) (&D_8011514E))) - D_80115143) * 2;
+          }
+          ot = func_80140D68(ot, p, i, D_801917BC[c[0] & 7], t);
+          if (((i == 2) && ((*((s16 *) (c + 9))) == 1)) && ((*((s16 *) (c + 12))) != 0))
+          {
+            ot = func_80140D68(ot, p, 2, 8, ((*((s16 *) (c + 12))) & 0xF) * 2);
+          }
+        }
+      }
+      if (i == c3)
+      {
+        s32 m = b[0];
+        /* [L1] compare against `i`, NOT against the literal 3. */
+        if ((m == i) && ((b[-2] & 8) != 0))
+        {
+          s16 j;
+          s32 k;
+          s32 t3v;
+          u8 *q = ((u8 *) ot) + 0x14;
+          s16 y;
+          j = 0;
+          k = m;
+          t3v = m * 4;                  /* [L3] explicit, must sit before the 3 constants */
+          pb = (u16 *) (&D_800B9A02);
+          m24 = 0xFFFFFF;
+          mhi = 0xFF000000;
+          do
+          {
+            if (j == 0)
+            {
+              if (D_80115140[k] == 0)
+              {
+                continue;
+              }
+              q[-7] = 0x30;
+              y = (*e) - 4;
+            }
+            else
+            {
+              s32 k2 = k * 2;
+              if ((((s8 *) D_80115158)[k2] - ((s8 *) D_80115140)[k]) < 2)
+              {
+                continue;
+              }
+              q[-7] = 0x38;
+              y = (*e) + 3;
+            }
+            *((s16 *) (q - 10)) = y;
+            *((u32 *) ot) = 0x4000000;
+            q[-8] = 0x78;
+            *((u32 *) (q - 0x10)) = 0x64808080;
+            *((s16 *) (q - 6)) = 0x4056;
+            *((s16 *) (q - 0xC)) = (D_801912CC + ((u16) *((u16 *) (((u8 *) D_8011516A) + t3v)))) + 0x4A;
+            y = 8;
+            *((s16 *) (q - 2)) = y;
+            *((s16 *) (q - 4)) = y;
+            *((u32 *) ot) = ((*((u32 *) ot)) & mhi) | (D_800AE7BC[*pb].ot[2] & m24);
+            {
+u32 *op;
+              op = D_800AE7BC[*pb].ot;
+              op[2] = (op[2] & mhi) | (((u32) ot) & m24);
+            }
+            q += 0x14;
+            ot += 5;
+          } while (++j < 2);
+
+        }
+      }
+      i = i + 1;
+    }
+    while (i < n);
+  }
+  return ot;
+}
diff --git a/.run/P36/agents/ov_SC04_011__func_80148AFC/body.c b/.run/P36/agents/ov_SC04_011__func_80148AFC/body.c
index 67714e48fb..a45b9199ff 100644
--- a/.run/P36/agents/ov_SC04_011__func_80148AFC/body.c
+++ b/.run/P36/agents/ov_SC04_011__func_80148AFC/body.c
@@ -1,21 +1,23 @@
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80191F24[];
+    extern s32 (*D_80191F24[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    s32 sVar3 = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
     switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80191F24[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80191F24[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
         if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
-        *(u16 *)(iVar5 + 0x12) = (sVar3 + ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8))) & 0xFFF;
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
         return 1;
     }
 }
diff --git a/.run/P36/agents/ov_SC04_011__func_80148AFC/mechanism.md b/.run/P36/agents/ov_SC04_011__func_80148AFC/mechanism.md
index ffb827d03c..9ce27d2830 100644
--- a/.run/P36/agents/ov_SC04_011__func_80148AFC/mechanism.md
+++ b/.run/P36/agents/ov_SC04_011__func_80148AFC/mechanism.md
@@ -1,6 +1,131 @@
-# func_80148AFC (ov_SC04_011_after.c) — T7 agent c3 — IN PROGRESS
+# func_80148AFC (src/ov_SC04_011/ov_SC04_011_after.c) — T7 agent c3
 
-Best so far: score 6 (COUNT, 70 vs 71) — body.c. The whole case-0x53/0x73 block is byte-identical after
-rewriting `if (lo != 0x80 || hi != 0x80) { ...; return 1; } return 0;` as the natural
-`if (lo == 0x80 && hi == 0x80) return 0; ...; return 1;` (removes 3 levers: both $2 pins, the $3 pin and the memory barrier).
-Remaining: the $5 pin + launder class (the missing `move s1,a1` copy) — same residual as the twins func_80148E54 / func_80148D44.
+**CLOSED: score 0** (`--try ... body.c --body`: "score 0 (OTHER; mine 71 ins, target 71) — MATCH"). All six NEEDED
+levers are gone: no pin, no `asm`, no added `volatile`, no zero term. The whole-object gate is still the coordinator's job.
+`PACK/body.c` is the text to bank.
+
+## The three source moves (it takes all three)
+
+1. **The 0x41 handler gets the angle as its second argument**: `D_80191F24[...](a0, tmp)`, with the table declared in the
+   body as `extern s32 (*D_80191F24[])(void *, s32);` (the TU's `ActorFn` is `s32 (*)(void *)`, one argument too narrow).
+2. **The raw angle variable is reused for the second `ratan2` result, and it is the SECOND operand of the final sum**:
+   `tmp = ratan2(...); *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;`, with `s32 ang = tmp;` straight after the first
+   computation.
+3. **The analog-stick test is written the natural way**, early `return 0` first:
+   `if (lo == 0x80 && hi == 0x80) return 0; ...; return 1;` in place of `if (lo != c80 || (hi = ...) != 0x80) {...} return 0;`.
+
+What each one does on its own, all measured with `--try`:
+
+| body | score |
+|---|---|
+| `body_free.c` (the levers just deleted) | 23 (72 vs 71) |
+| move 3 only (`scratch/c1.c`) | 6 (70 vs 71): the whole 0x53/0x73 block matches, the `move s1,a1` is still missing |
+| moves 3+1, one variable used everywhere (`c3.c`) | 8: the angle sits in `s1` and the 0x41 path gains a `move a1,s1` |
+| moves 3+1, `tmp` for the call, `ang = tmp` for the sum, second ratan2 in a new local (`c4.c`, `a3.c`) | 8, same as above |
+| moves 3+2, no call argument (`a4.c`) | 6 |
+| moves 1+2 with the old `||` / `return 0`-last shape (`a2.c`) | 20 |
+| all three, but written `(tmp + ang)` (`a1.c`) | 9: the operand order matters, see (b) |
+| **all three (`body.c`)** | **0** |
+
+## (a) The residual in one sentence
+
+Two separate defects. (i) The target computes the angle into `a1` (`andi a1,v0,0xfff`) and copies it into `s1` in the
+delay slot of the first switch branch (`move s1,a1`); every lever-free spelling writes `andi s1,v0,0xfff` straight away,
+so it comes out one instruction short. That is the same class as the twins func_80148E54 and func_80148D44. (ii) In
+the 0x53/0x73 block the target loads `+0xAE` twice, rematerialises 0x80 and compares `hi` against `lo`, while the `||`
+spelling shares the load and emits an extra `andi 0xffff` and two `nop`s.
+
+## (b) The mechanism: passes and decisions (proved on bytes and on the RTL dumps in `scratch/dumps_final/`)
+
+**Defect (i) is a missing call argument that the disassembly does not show.** In the target, `a1` is written at `0x3260`
+and read only by the `move` at `0x3270`. On the 0x41 path it then reaches `jalr v0` at `0x32c4` without being written.
+So the handler receives the angle in `a1` and no instruction is needed to pass it. That is the extra consumer that
+keeps the producer alive. The previous agent's census ("the producer has exactly one consumer") counted explicit reads
+only. A `jal`/`jalr` reads `$a0-$a3` implicitly.
+
+Giving the call that argument is necessary but not enough (score 8). cse still merges the two variables:
+
+- **cse.c:846-862 (`make_regs_eqv`)**. When the copy `ang = tmp` is processed, `ang` becomes the class's canonical
+  register only if its last mention is *later* than `tmp`'s: `uid_cuid[regno_last_uid[new]] > uid_cuid[regno_last_uid[firstr]]`
+  (line 856). `regno_last_uid` comes from `reg_scan` (regclass.c:1764) and counts sets as well as uses. With `ang` used
+  in the 0x53 block, which comes after the 0x41 block, `ang` wins. Two things follow:
+  - the **cse.c:7454-7471 swap** fires (its guard at line 7459 is `qty_first_reg[...] == REGNO(dest)`). The producer is
+    rewritten to set `ang` and the copy becomes a dead `tmp = ang`;
+  - `canon_reg` rewrites the 0x41 argument `(set (reg a1) tmp)` to `ang`. The 0x41 label has one use and is preceded
+    by a barrier, so cse follows the jump into it (cse.c:8106). `tmp` is then dead after the copy. (Dump `dumps_c4`:
+    insn 46 sets reg 88 = `ang`, and insn 75 is `(set a1 (reg 88))`.)
+- **Move 2 reverses that comparison.** Reusing `tmp` for the second `ratan2` result puts a mention of `tmp` after
+  `ang`'s last mention. The sum is stored to a `u16`, so it is narrowed and expanded one operand per insn: insn 143
+  `(set (reg:HI 122) (subreg:HI (reg 88 ang)))`, then insn 145 `(set (reg:HI 123) (subreg:HI (reg 75 tmp)))`. `tmp`'s last
+  mention (145) is later than `ang`'s (143), so `ang` does not become canonical. The swap does not fire and the 0x41
+  argument keeps `tmp`. Dump `dumps_final/cse.fn`: insn 46 `(set (reg/v 75 tmp) (and ...))`, insn 49
+  `(set (reg/v 88 ang) (reg/v 75))` kept, insn 75 `(set (reg a1) (reg/v 75))` kept. Written `(tmp + ang)`, the order is
+  reversed, `ang` wins and the swap comes back (`dumps_a1`: insn 46 sets 88). That is why `a1.c` scores 9.
+- **combine.c:1458.** `tmp` is now live past the copy (read by insn 75 on the 0x41 path), so the copy (insn 49) carries
+  no `REG_DEAD` for `tmp`. `added_sets_2 = ! dead_or_set_p (i3, i2dest)` is 1, the merged pattern would be a two-SET
+  PARALLEL, it is not recognised, and combine keeps both insns. `dumps_final/comb.fn` insn 49 has no death note. The
+  reused `tmp = v0` from the second call is folded into the add (insn 147 reads `v0` directly), so the second live range
+  costs nothing.
+- **Allocation.** `ang` is live across the second `ratan2` call, so it gets `s1`. `tmp` is copied into the argument
+  register `a1`, so it prefers and gets `a1`. That also explains the register in the twins: their `tmp` sits in `a0`,
+  the first argument of their argument-less handler calls. After sched, the copy is the only entry-block insn that
+  `fill_simple_delay_slots` can move into the first `beq`'s slot.
+
+**Defect (ii) is cse's path following plus reorg.** In `if (A && B) return 0; call...; return 1;` both failing tests
+jump to one label, so it has two uses. `cse_end_of_basic_block` (cse.c:8106) only follows a jump whose label has one
+use, so the call block starts with an empty table: the `+0xAE` load and the 0x80 are redone (`lhu a1,174(s0)`,
+`li v0,128`). On the fall-through of `bne lo,0x80`, `record_jump_equiv` (cse.c:5791) makes `lo` equal to 0x80, and the
+second test's 0x80 is canonicalised onto `lo`'s register (`beq v0,a0`). The `return 0` block comes before the call
+block in the RTL, so reorg steals `move v0,zero` into the `beq` slot and the call block falls into the epilogue.
+Moving the `||` form's early exit to the front repaired all of it at once: that is `c1.c`, 23 to 6.
+
+## (c) Moves that closed it
+
+Listed at the top. One-liners:
+- pass the value the target leaves in `$aN` as argument N-4 of the handler call on the other path, and widen the
+  callee's declaration;
+- reuse the producer variable for the later temporary, as the second operand of the final sum, so its last mention
+  comes after the copy destination's;
+- `if (lo == 0x80 && hi == 0x80) return 0;` ahead of the work.
+
+## (d) Generator proposals
+
+**R22 "hidden argument"**: when a COUNT residual is missing a reg-reg copy whose source `$aN` has no explicit reader in
+the target after the copy, but reaches a `jal`/`jalr` on some path without being written, add that variable as
+argument N-4 of that call and widen the callee's (or the table's) declaration to match.
+
+**R23 "stay canonical"**, the partner that makes R22 stick: when a surviving copy `dst = src` is folded because cse
+made `dst` canonical, move `src`'s last mention after `dst`'s. Reuse `src` for the next temporary whose use comes
+after `dst`'s last use, and put it as the later operand. The test to evaluate is cse.c:856.
+
+Both are cheap to compute from the target and the C text. The "reaches a call without being written" check is a
+straight-line scan per path. Neither changes the score alone on this body (R22 alone: 6 to 8, worse; R23 alone: 6),
+which is the METHOD §5 "joint edit" shape. A beam that drops non-improving children cannot find them.
+
+## (e) What did not work (byte evidence)
+
+See the table in "The three source moves". Also: `ang = tmp` placed inside `case 0x53` (`c2.c`) reaches 71
+instructions with the copy present, but in the case block after the `lhu`, with `tmp` in `v1` and the subject in `a0`,
+scoring 13. The copy really is in the entry block in the target. `fill_eager_delay_slots` would have preferred the
+fall-through `slti` for an EQ branch (`mostly_true_jump` returns 0), so the slot can only have been filled by
+`fill_simple_delay_slots` from an insn before the branch.
+
+## (f) Where the method fell short
+
+- **The census of consumers missed implicit reads.** The twin's mechanism.md concluded "unreachable body-only" from
+  "the producer has exactly one consumer". A call reads `$a0-$a3` with no instruction. METHOD item 3's first bullet
+  ("a dropped call argument") was the answer, but it was hidden because the call is on a different switch path from
+  the copy. Any consumer census should count a `jal`/`jalr` as reading every argument register that is live, unwritten,
+  at that point.
+- **The register the target picked was the clue.** `a1` (and `a0` in the twins) is not what first-fit gives after
+  `v0`/`v1`. A value in the second argument register with no visible reader asks "which call reads it?". An
+  alloc-table pass should flag argument-register placements that have no visible reader.
+- **A neighbour's `@stuck`/"unreachable" claim was wrong again**, as METHOD item 0 warns. It was well argued inside its
+  premises, and one premise (the consumer count) was measured with a blind instrument.
+
+## Twins, prediction only (not worked, per the brief)
+
+func_80148E54 and func_80148D44 have the same entry block with `tmp` in `a0`, and their 0x41 handler calls pass
+nothing. Prediction: pass the angle as the handler's **first** argument (`D_80191FA4[...](tmp)`,
+`D_80191F64[...](a)`), plus R23 if cse still merges: `tmp = ratan2(...); return (ang + tmp) & 0xFFF;` (the sum there is
+SImode, so check which operand is mentioned last in `.jump`). This has not been checked on bytes.
diff --git a/.run/P36/agents/ov_SC04_011__func_80148D44/body.c b/.run/P36/agents/ov_SC04_011__func_80148D44/body.c
new file mode 100644
index 0000000000..a9557e4e50
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_80148D44/body.c
@@ -0,0 +1,24 @@
+s32 func_80148D44(void) {
+
+    extern s32 D_801151D4;
+    extern u8 D_80126C01;
+    extern u16 D_80126C02;
+    extern u16 D_80126C06;
+    extern s16 (*D_80191F64[])(s32);
+    s32 p = D_801151D4;
+    s32 tmp = (ratan2(*(s32 *)(p + 0x44) - *(s32 *)(p + 0x50),
+                      *(s32 *)(p + 0x48) - *(s32 *)(p + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
+
+    switch (D_80126C01) {
+    case 0x41:
+        return D_80191F64[D_80126C02 >> 12](tmp);
+    case 0x53:
+    case 0x73:
+        if ((D_80126C06 & 0xFF) == 0x80 && (D_80126C06 >> 8) == 0x80) {
+            return -1;
+        }
+        tmp = ratan2((D_80126C06 & 0xFF) - 0x80, 0x80 - (D_80126C06 >> 8));
+        return (ang + tmp) & 0xFFF;
+    }
+}
diff --git a/.run/P36/agents/ov_SC04_011__func_80148D44/mechanism.md b/.run/P36/agents/ov_SC04_011__func_80148D44/mechanism.md
new file mode 100644
index 0000000000..566eba26e0
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_80148D44/mechanism.md
@@ -0,0 +1,51 @@
+# func_80148D44 (src/ov_SC04_011/ov_SC04_011_after.c): T7 agent c12, twin of func_80148E54
+
+**CLOSED: score 0** (`--try ... body.c --body`: "score 0 (OTHER; mine 68 ins, target 68) — MATCH"). Both NEEDED levers
+(the `$4` pin and the keepalive `asm`) are gone. There is no pin, no `asm`, no added `volatile` and no zero term.
+`PACK/body.c` is the text to bank. The whole-object gate is still the coordinator's job.
+
+## The moves (same pair as func_80148E54; the full reading is in ../ov_SC04_011__func_80148E54/mechanism.md)
+
+1. **Pass the angle to the 0x41 handler as its first argument**: `D_80191F64[D_80126C02 >> 12](tmp)`, with the in-body
+   table declared `extern s16 (*D_80191F64[])(s32);`. Before, it was `s32 D_80191F64[]` cast to `s16 (*)()` at the call.
+2. **Reuse the angle variable for the second `ratan2` result**, as the later operand: `tmp = ratan2(...);
+   return (ang + tmp) & 0xFFF;`.
+
+`body.c` also rewrites the tree's goto ladder as the `switch` that func_80148E54 and func_80148AFC use (the same bytes)
+and drops the `p`/`res`/`d`/`e` temporaries. The minimal-edit form, which keeps the goto ladder and changes only moves
+1 and 2, also scores 0 (`scratch/d2.c`). So the rewrite is for readability only and does not carry the close.
+
+| body (all `--try`, real TU) | score |
+|---|---|
+| `body_free.c` | 6 (67 vs 68), the copy is missing |
+| switch form, move 2 only (`scratch/d4.c`) | 6 (67 vs 68) |
+| switch form, move 1 only (`scratch/d5.c`) | 7 (67 vs 68) |
+| both, `(tmp + ang)` (`scratch/d3.c`) | 1 (68 vs 68), only the `addu` operand order |
+| goto ladder, both moves (`scratch/d2.c`) | **0** |
+| **switch form, both moves (`body.c` = `scratch/d1.c`)** | **0** |
+
+## (a) Residual
+
+The target has `andi a0,v0,0xfff` at 0x3498 and `move s0,a0` in the first `beq`'s delay slot at 0x34ac. Then `a0`
+reaches `jalr v0` at 0x3504 on the 0x41 path unwritten, so the handler receives the angle. The lever-free body folded
+the copy and was one instruction short.
+
+## (b) Mechanism
+
+This is the same as the twin, which was proved on its dumps. This body's own claims rest on the bytes above, not on its
+own dumps. The `tu_free` `d = D_80126C01;` statement already separated producer and copy, so cse.c:7454's adjacency
+did not apply there. But in the switch form the subject is read in the switch, and both forms close, so adjacency does
+not decide anything once move 1 gives the producer its second (implicit) consumer:
+- cse.c:856 (`make_regs_eqv`): the reuse puts `tmp`'s last mention in the sum insn, tying `ang`'s. The strict `>` keeps
+  `tmp` canonical, so the swap at cse.c:7454 cannot fire and the argument is not re-canonicalised to `ang`.
+- combine.c:1458: `tmp` is live past the copy (the call argument), so `added_sets_2` is 1 and combine keeps the copy.
+
+## (d) Generator proposal
+
+Same as the twin: R22 "hidden argument" together with R23 "stay canonical", emitted as one joint candidate.
+
+## (f) Method note
+
+The goto ladder in the tree body is a decompiler artefact. The same switch as in the twin produces identical bytes, so a
+twin-aware tool could have proposed the E54 body text directly here, with the globals substituted for the `arg0`
+offsets.
diff --git a/.run/P36/agents/ov_SC04_011__func_80148E54/body.c b/.run/P36/agents/ov_SC04_011__func_80148E54/body.c
index 2a9c012cbb..78e443c8ff 100644
--- a/.run/P36/agents/ov_SC04_011__func_80148E54/body.c
+++ b/.run/P36/agents/ov_SC04_011__func_80148E54/body.c
@@ -1,19 +1,21 @@
 s32 func_80148E54(s32 arg0) {
 
     extern s32 D_801151D4;
-    extern s16 (*D_80191FA4[])();
-    s32 ang = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+    extern s16 (*D_80191FA4[])(s32);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
                       *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
     switch (*(u8 *)(arg0 + 0xA9)) {
     case 0x41:
-        return D_80191FA4[*(u16 *)(arg0 + 0xAA) >> 12]();
+        return D_80191FA4[*(u16 *)(arg0 + 0xAA) >> 12](tmp);
     case 0x53:
     case 0x73:
         if ((*(u16 *)(arg0 + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(arg0 + 0xAE) >> 8) == 0x80) {
             return -1;
         }
-        return (ang + ratan2((*(u16 *)(arg0 + 0xAE) & 0xFF) - 0x80,
-                             0x80 - (*(u16 *)(arg0 + 0xAE) >> 8))) & 0xFFF;
+        tmp = ratan2((*(u16 *)(arg0 + 0xAE) & 0xFF) - 0x80,
+                             0x80 - (*(u16 *)(arg0 + 0xAE) >> 8));
+        return (ang + tmp) & 0xFFF;
     }
 }
diff --git a/.run/P36/agents/ov_SC04_011__func_80148E54/mechanism.md b/.run/P36/agents/ov_SC04_011__func_80148E54/mechanism.md
index 2f23033d04..ba859fa956 100644
--- a/.run/P36/agents/ov_SC04_011__func_80148E54/mechanism.md
+++ b/.run/P36/agents/ov_SC04_011__func_80148E54/mechanism.md
@@ -1,178 +1,99 @@
-# func_80148E54 (ov_SC04_011 / src/ov_SC04_011/ov_SC04_011_after.c) — T7 residue
+# func_80148E54 (src/ov_SC04_011/ov_SC04_011_after.c): T7 agent c12
 
-**Status: NOT CLOSED. Best score 6 (COUNT; mine 66 ins, target 67)** — the untouched lever-free text,
-cleaned (`PACK/body.c`, one variable, the stale `// !FAKE:` comment dropped). The mechanical search's
-best of 4 (`R14 param-width arg0 s32->u16` + `R10 param-copy arg0`) is a *worse* body: it lies about
-the parameter's type, does not restore the missing instruction, and buys its 2 points by shifting the
-`lbu` base. ~90 hand-reasoned spellings were compiled through `--try` this session; the mechanism is
-now read from the compiler's source AND from the RTL dumps, and the class is argued **unreachable
-body-only** for this particular function. The same is true of its twin `func_80148D44`.
+**CLOSED: score 0** (`--try ... body.c --body`: "score 0 (OTHER; mine 67 ins, target 67) — MATCH"). Both NEEDED levers
+(the `$4` pin and the launder `asm`) are gone. There is no pin, no `asm`, no added `volatile` and no zero term.
+`PACK/body.c` is the text to bank. The whole-object gate is still the coordinator's job.
+
+The earlier agent's reading, which argued this body "unreachable body-only", is kept verbatim at
+`scratch/mechanism_prev_agent.md`, and its best body is at `scratch/body_prev_agent.c`. Its two pass readings are
+correct: cse.c:7454 for the adjacent copy and combine.c:1458 for the separated one. The unreachability conclusion was
+wrong. It rested on the census "the producer's value has exactly one consumer", and that census did not count the
+implicit `$a0` read of the `jalr` on the 0x41 path. See (f).
+
+## The two source moves. It takes both.
+
+1. **Give the 0x41 handler the angle as its first argument**: `D_80191FA4[...](tmp)`, with the in-body table declared
+   `extern s16 (*D_80191FA4[])(s32);`. It was `(*[])()` before, which passes nothing.
+2. **Reuse `tmp` for the second `ratan2` result, and make it the later operand of the sum**:
+   `tmp = ratan2(...); return (ang + tmp) & 0xFFF;`, with `s32 ang = tmp;` right after the first computation.
+
+| body (all `--try`, real TU) | score |
+|---|---|
+| `body_free.c` / the earlier agent's `body.c` | 6 (66 vs 67), the copy is missing |
+| move 1 only (`scratch/t1.c`) | 7 (66 vs 67). The copy is still missing and the 0x41 path gains `move a0,s1` |
+| move 2 only (`scratch/t3.c`) | 6 (66 vs 67) |
+| both, written `(tmp + ang)` (`scratch/t4.c`) | 1 (67 vs 67). The copy is present; only the `addu` operand order differs: `addu v0,v0,s1` vs `addu v0,s1,v0` |
+| **both, `(ang + tmp)` (`body.c` = `scratch/t2.c`)** | **0** |
 
 ## (a) The residual in one sentence
 
-The target computes the masked angle into a caller-saved register and then copies it into the
-callee-saved register that carries it across the switch — `andi a0,v0,0xfff` … `move s1,a0`, the copy
-landing in the delay slot of the first dispatch branch — while every lever-free spelling folds the
-copy away and writes `andi s1,v0,0xfff` directly, one instruction short (66 vs 67).
+The target computes the masked angle into `a0` (`andi a0,v0,0xfff` at 0x35b0) and copies it into `s1` in the delay slot of
+the first switch branch (`move s1,a0` at 0x35c0). Every earlier spelling wrote `andi s1,v0,0xfff` directly and came out
+one instruction short. In the target, `a0` is never written again before the `jalr v0` at 0x3614 on the 0x41 path. The
+handler therefore receives the angle as its first argument at no instruction cost. That hidden read is the second
+consumer that keeps the producer alive.
 
-```
-target                    mine
-addiu v0,v0,-1024         addiu v0,v0,-1024
-andi  a0,v0,0xfff         andi  s1,v0,0xfff
-lbu   v1,169(s0)          lbu   v1,169(s0)
-li    v0,83               li    v0,83
-beq   v1,v0,3628          beq   v1,v0,3624
-move  s1,a0     <- extra  slti  v0,v1,84      (reorg fills the slot from the fall-through)
-```
+## (b) The mechanism: passes and decisions, proved on the RTL dumps
 
-The copy is **unconditional and in the entry block** — proven, not assumed: it is in the delay slot of
-`beq v1,v0,3628`, and it cannot have been stolen from that branch's target thread because the 0x73
-branch at `0x35e4` reaches the same target `0x3628` with a `nop` slot and still needs `s1`. And the
-producer's value has **exactly one use** in the whole target: `a0` is written at `0x35b0` and read only
-at `0x35c0` (`s1` likewise: written `0x35c0`, read once at `0x3660`).
+Dumps are in `scratch/dumps_{t1,t2,t4}/` (made by `scratch/dump.py`: the real TU with the body spliced in, then the
+recipe's cpp and cc1 with `-dr -ds -dj -dc -dl -dg -dS`). Pseudo 73 is `tmp` and pseudo 86 is `ang`.
+In `.jump` the producer is insn 40 `(set 73 (and 85 4095))`, the copy is insn 43 `(set 86 73)` and the argument is
+insn 67 `(set a0 73)`.
 
-## (b) The passes and the decisions — two killers, both dump-verified
+- **cse.c:846-862 (`make_regs_eqv`)**. When insn 43 makes 86 equivalent to 73, 86 becomes the class's canonical register
+  only if `uid_cuid[regno_last_uid[86]] > uid_cuid[regno_last_uid[73]]` (line 856). `regno_last_uid` is set by `reg_scan`
+  at regclass.c:1764 and counts sets as well as uses.
+  - Move 1 only (t1): 73's last mention is insn 67, in the 0x41 block. 86's last mention is insn 135, the sum in the 0x53
+    block, which comes after the 0x41 block. So 86 wins. The **cse.c:7454-7471 swap** then fires. `.cse` shows insn 40
+    rewritten to `(set 86 (and ...))`, the copy gone, and insn 67 re-canonicalised to `(set a0 86)`. The angle lives in
+    `s1` and the call path pays a `move a0,s1`. That is the 7.
+  - Both moves (t2): the reuse adds insn 133 `(set 73 v0)` and puts 73 in the sum insn 136 `(plus 86 73)`. The last
+    mentions of 73 and 86 are now the same insn, 136. The test at line 856 is a strict `>`, so 86 does not become
+    canonical and the swap does not fire. `.cse` keeps insn 40 setting 73, insn 43 `(set 86 73)` and insn 67 `(set a0 73)`.
+  - `(tmp + ang)` (t4): the cse result is identical to t2, because the tie holds whichever operand comes first. The
+    SImode sum is one `addsi3` insn that mentions both. The operand order only reaches the final `addu`, which is the
+    score 1. This differs from sibling func_80148AFC. There the sum is narrowed to HImode one operand per insn, so the
+    order decided the cse tie itself (c3's `a1.c` scored 9).
+- **combine.c:1458**. In t2, 73 stays live past the copy because insn 67 reads it on the 0x41 path. So the copy carries no
+  `REG_DEAD` for 73 (`.combine`: insn 43 `(set 86 73)` with an empty note list). `added_sets_2 = ! dead_or_set_p (i3,
+  i2dest)` is 1, the merged two-SET PARALLEL is not recognised, and combine keeps both insns.
+- **Allocation and slot**. 86 is live across the second `ratan2` call, so it gets `s1`. 73 is copied into `a0` for the
+  call, so it prefers and gets `a0`. The copy is then the only entry-block insn `fill_simple_delay_slots` can move
+  into the first `beq`'s slot, which is the target's layout. This last step was not dump-verified; the bytes show it.
 
-**Killer 1 — cse1, `cse.c:7439-7502`** ("Special handling for `(set REG0 REG1)` where REG0 is the
-cheapest"). The guard is
-```c
-  if (n_sets == 1 && … GET_CODE (SET_SRC (sets[0].rtl)) == REG
-      && NEXT_INSN (PREV_INSN (insn)) == insn
-      && … (qty_first_reg[reg_qty[REGNO (SET_SRC …)]] == REGNO (SET_DEST …)))
-    { rtx prev = PREV_INSN (insn); while (prev && GET_CODE (prev) == NOTE) prev = PREV_INSN (prev);
-      if (prev && GET_CODE (prev) == INSN && SET_DEST (PATTERN (prev)) == SET_SRC (sets[0].rtl)) { … } }
-```
-It rewrites the *producer's* destination to the copy's destination and turns the copy into a dead
-store. **Verified on the real spliced TU:** `.jump` holds
-`(insn 40 (set (reg/v:SI 73) (and:SI (reg:SI 85) (const_int 4095))))` followed by
-`(insn 43 (set (reg/v:SI 86) (reg/v:SI 73)))`; in `.cse` insn 43 is gone and insn 40 sets reg 86
-directly. So §455's reading — "combine merges a single-use def into its copy" — names the wrong pass
-for the adjacent case: **cse gets there first**, and its precondition is `prev` (skipping only NOTEs).
+## (c) The moves, one line each
 
-**Killer 2 — combine, `combine.c:1458` + `flow.c:2086-2091`.** Break cse's adjacency (put any real insn
-between producer and copy) and cse leaves the copy alone — but then `try_combine (i3 = the copy,
-i2 = the producer)` fires: `added_sets_2 = ! dead_or_set_p (i3, i2dest)` is 0 because the producer dies
-at the copy, the substitution recognises as `andsi3`, and i2 is deleted. **Verified on dumps** with
-`s32 k = *(u8 *)(arg0 + 0xA9);` inserted between them (variant `w4`): the copy is still present in
-`.cse`, and `.combine` shows `(insn 47 (set (reg/v:SI 86) (and:SI (reg:SI 85) (const_int 4095))))`
-with insn 40 a `NOTE_INSN_DELETED`.
-
-**The three blockers `can_combine_p` actually admits** (`combine.c:803-960`), i.e. the complete
-lever-free option set:
-1. **No LOG_LINK** — `flow.c:2086` builds one only when `y && (BLOCK_NUM (y) == blocknum)`, so a real
-   `CODE_LABEL` between producer and copy blocks combine outright.
-2. **The producer still live at the copy** — `dead_or_set_p` false ⇒ `added_sets_2` ⇒ the merged
-   pattern would be a PARALLEL of two sets, unrecognisable on MIPS ⇒ combine fails.
-3. **A CALL between them** — `combine.c:929`, `INSN_CUID (insn) < last_call_cuid && ! CONSTANT_P (src)`.
-(The tree body uses a fourth, forbidden one: the `launder` `asm` on `$4` sits between them and
-`can_combine_p` refuses ASM_OPERANDS, `combine.c:868-870`. `.combine` for the tree body shows
-`(insn 42 (set (reg/v:SI 4 a0) (and …)))`, `(insn 44 asm_operands)`, `(insn 47 (set (reg/v:SI 87)
-(reg/v:SI 4 a0)))`, and sched1 then sinks insn 47 past the `lbu`/`li` so reorg can fill the slot.)
-
-**Why the register is `a0` and not `v0` is NOT a separate problem.** With the launder but *no* pin
-(diagnostic `d1`) the copy survives, but sched1 keeps it adjacent to the producer and local-alloc gives
-the short-lived quantity `v0` — score 4, `andi v0,v0,0xfff ; move s1,v0`. In the target the copy is
-scheduled *after* `li v0,83`, so `v0` is occupied and first-fit hands out `a0`. The colour follows the
-schedule; **the only real problem is keeping the copy at all.**
-
-## (c) Why this body cannot pay for any of the three blockers
-
-- **Blocker 2 (a second read) has no free home.** The producer's value has exactly one consumer in the
-  target's 67 instructions, and every instruction in the entry block is accounted for (`lbu`, `li`,
-  `beq`). Any second read costs an instruction. Worse, per agent a-80166F58's Step 3 (independently
-  confirmed here), a second read placed *after* the copy is neutralised anyway: `cse.c:canon_reg`
-  re-canonicalises it onto the copy's destination and the producer drops back to one use. It must sit
-  **before** the copy — where there is nothing for it to be. C's own folding kills the free candidates:
-  `tmp & 0`, `tmp - tmp`, `tmp ^ tmp` are gone at `fold-const.c` before expand (measured: `p3`, `p4`
-  score 6), and a dead second reader (`s32 dead = tmp;`) is deleted by flow (`p1`, `p2` score 6).
-- **Blocker 1 (a label) has no free home either.** A label emits no bytes, so the target *could* carry
-  one — but it must be referenced or jump1 deletes it (`goto L; L:` measured: `w3`, `y3` score 6/8),
-  and **no branch in the target targets any address between `0x35b0` and `0x35b4`**. Paying for a real
-  join costs the diamond's branch (`y5`, `y6`, `z10`, `r1`, `r3`: 67 instructions but the extra one is
-  a `nop` or a compare, never the copy).
-- **Blocker 3 (a call) is impossible:** the only call before the switch is the `ratan2` that *produces*
-  the value, so `INSN_CUID (producer) > last_call_cuid` always.
-
-**Cross-check against the binary.** I scanned all 4,284 objects under `build/src` for the shape
-"ALU insn writing a caller-saved register, no control flow, then `move sN,<that register>`"
-(101 distinct hits). Every lever-free precedent I read pays one of the two prices:
-- `func_8015D1B8` (`ov_SC03_099_jr_8015C32C.c:1725`) — `sum` has **two** uses (`*(u16*)(obj+0x10) =
-  sum & 0xFFF;` then `keep = sum;`); the drafter's own comment says "AFTER the store — this is what
-  keeps the `$s0` copy alive".
-- `func_8014DD8C` (`src/shared/ov/func_8014DD8C.h:18`) and `func_8018CBB0`
-  (`ov_SC03_001_jr_8018B8DC.c:4058`) — a **narrow (`s16`) local with two consumers** (lane B 1c-1).
-- `func_80180CFC` (`ov_SC06_032_jr_8017C24C.c:5487`) — `iVar1 = t;` followed by `t = t << 16;`, a real
-  second read of `t` *before* it is overwritten.
-- `func_801864E4` (`ov_SC05_010_jr_8018473C.c:4076`) — `sel = cond ? A : B; start = sel;`, a **join
-  label** between producer and copy.
-None of the four shapes exists in `func_80148E54`, and none can be created in it for zero bytes.
+- Pass the value the target leaves unwritten in `$a0` as the first argument of the handler call on the other switch path,
+  and widen the in-body table declaration to `(*[])(s32)`.
+- Reuse the producer variable for the second `ratan2` result, as the later operand of the final sum, so that its last
+  mention is not earlier than the copy destination's.
 
 ## (d) GENERATOR PROPOSAL
 
-**R20 "copy-keeper pair" (a paired move, plus a cheap unreachability predicate).** When the residual is
-COUNT and the missing instruction is a reg-reg `move S,C` whose source `C` is written by the
-*immediately preceding* instruction in mine, emit ONE candidate per (separation × blocker) pair — the
-nearest independent following statement moved *between* the producer and the copy (which is the only
-thing that defeats `cse.c:7454`) **crossed with** one of combine's three blockers (a second read of the
-producer inserted *before* the copy, an if/else diamond whose merge label sits between them, or a call
-moved between them) — because neither half changes the score alone, which is exactly why every
-single-move family in the registry sits at the same number on this class; and *before* spending the
-compiles, refuse the class outright when (i) the producer's value has exactly one consumer in the C
-text and (ii) no branch in the target targets an address strictly between the producer and the copy,
-since then all three blockers are unaffordable and the body is unreachable body-only.
+This is the same pair c3 named for func_80148AFC, and these two bodies are its second and third instances.
+**R22 "hidden argument"**: when a COUNT residual is missing `move sK,$aN` and `$aN` reaches a `jal`/`jalr` on some path
+without being written, pass the copy's source variable as argument N-4 of that call and widen the callee or table
+declaration.
+**R23 "stay canonical"**: when R22 alone gets worse (the call path gains `move $aN,sK`), reuse the source variable for the
+next temporary after the copy destination's last use. In an SImode sum, put it as the later operand so that the tie at
+cse.c:856 holds. That position is also what the `addu` operand order wants.
+Neither move improves the score alone (7 and 6 from 6), so a beam that drops non-improving children cannot find the
+pair. The generator has to emit them together.
 
-This is new against the four docstrings in `tools/delever.py`: `sink_merges` (R15) sinks a merge
-statement into if/else arms, `constant_holders` (R16) deletes a literal-holding local,
-`constant_run_splits` (R17) splits a run of equal constant stores, `bystander_moves` (R18) walks an
-independent statement within its block — all four are *single* moves over whole statements, and none
-of them is aimed at `cse.c:7454`'s adjacency precondition. It is also distinct from a-80166F58's
-proposed R19 ("second use before the copy"), which is one of R20's three blocker legs and is offered
-there without the separation half and without the unreachability gate.
+## (e) What did not work (byte evidence)
 
-## (e) What did NOT work — the byte evidence (all `--try` on the real TU, ~90 compiles)
-
-| spelling | score |
-|---|---|
-| one variable `s32 ang = EXPR;` (`PACK/body.c`) | 6 (66 ins) |
-| two variables adjacent; chained `ang = tmp = EXPR;`; nested block; `do { ang = tmp; } while (0)`; `(ang = tmp, 0)`; `(s32)` cast; `const`/`u32` producer; declaration order swapped | 6 each |
-| an intervening statement before the copy (`s32 k` / `u8 k` = the switch subject) | 6 (cse defeated, combine folds — dump-verified) |
-| lane B 1c-2 "re-set the SOURCE": `tmp = 0;` after the copy, `tmp = 0;` inside the case, `ang = 0;` after the switch, `tmp` reused for the second `ratan2` result | 6 each (flow deletes the dead store) |
-| lane B 1c-1 widths — 8 producer/destination width combinations **with** the intervening statement, and 6 single-variable narrow declarations (`u16`,`s16`,`short`,`unsigned short`) | 6 each; `u8`/`char` 11 (a real `andi 0xff` appears). Confirms the residual_moves ledger row: combine folds a narrowing of a value already masked to 12 bits |
-| free second reads: `tmp & 0`, `tmp + (tmp&0)` in the subject expression, `s32 dead = tmp;` before or after the copy | 6 each (fold-const / flow remove them) |
-| `goto L; L:` between producer and copy | 6 (jump1 deletes the jump, then the label) |
-| `while (0) {}`, `if (arg0) {} else {}`, `switch (0) { default: … }`, `switch (arg0) { default: … }` between them | 6 each |
-| **`ang = tmp;` moved inside `case 0x53:`** | 9, **67 ins, the copy present** — the block boundary really does keep it, but in the wrong block |
-| `if (k == 0x53/0x41) { ang = tmp; } else { ang = tmp; }`, `?:` with equal arms | 8 / 4, 67 ins — the 67th instruction is a `nop` or a hoisted compare, never the copy |
-| diagnostic (levers, not bankable): launder alone, no pin | 4, **67 ins, the copy present as `andi v0,v0,0xfff ; move s1,v0`** — proves the colour is a consequence of where sched1 puts the copy |
+The single moves and the operand order are in the table above. The earlier agent's ~90 spellings (listed in
+`scratch/mechanism_prev_agent.md` §e) all lacked move 1, so each one met the cse.c:7454 or combine.c:1458 killer.
 
 ## (f) Where the method fell short
 
-- **§455's one-line reading named the wrong pass.** "combine merges a single-use def into its copy" is
-  true only once the two insns are non-adjacent; for the adjacent form the killer is `cse.c:7454`, a
-  transformation with a *completely different* precondition (the immediately preceding insn). Chasing
-  combine first cost an hour of hypotheses that could not have worked. A pass attribution in a cookbook
-  entry should carry the `file:line` and the dump line that proves it — this one now does.
-- **The residual print does not say which side of the copy the extra instruction lives on.** "insert
-  `move s1,a0` after `beq`" reads as a scheduling fact; the load-bearing facts (the copy is
-  unconditional, its source has exactly one consumer, and no branch targets the gap) all had to be
-  recovered by hand from `objdump` on `build/src/ov_SC04_011/ov_SC04_011_after.o`. Printing the
-  *neighbourhood* of a COUNT insert, plus the target's use-count for the registers involved, would have
-  named the class in one look.
-- **The engine has no way to represent "two moves, neither of which changes the score".** The beam drops
-  a child that is not better and tails a child with the parent's score *and* diff signature, so a pair
-  whose first half is byte-neutral is structurally out of reach. That is the finding behind R20 and it
-  applies to every copy-survival class, not just this body.
-- **`--try` and the search share one scratch TU per pack** (`.run/P36/engine/score/<pack>/`). Two of my
-  batch runs came back as a bare Python traceback that re-running fixed; a per-invocation scratch dir
-  would make agent sweeps safe to run alongside anything else.
-- **A "no branch targets this gap" check is computable and would have ended the search in 30 seconds.**
-  It is offered as the R20 predicate above.
-
-## Twin
-
-`func_80148D44` has the byte-identical residual (score 6, mine 67 / target 68, `andi a0,v0,0xfff` …
-`move s0,a0`, `s0->a0 x1`) and the same census: its producer `a` has exactly one consumer, its
-`d = (s32)D_80126C01;` already separates producer from copy (so cse is already defeated there and
-**combine alone** is the killer), and no branch targets the gap. The reading transfers verbatim; the
-*text* does not (the twin reads globals, not `arg0` offsets), and since this body did not close there
-is no body text to share. If a future move closes one, it will close the other.
+- **A consumer census has to count implicit argument-register reads.** The earlier agent's unreachability argument was
+  valid given its premise. The premise ("`a0` is read only at 0x35c0") was measured with an instrument that treats a
+  `jalr` as reading nothing. Any census must treat a `jal`/`jalr` as reading every `$a0-$a3` that reaches it unwritten.
+  That check is a straight-line scan per path.
+- **The register was the clue.** A value placed in `a0` right after a call's result lands in `v0`, with no visible
+  reader, is not what first-fit gives. It is asking "which call reads it?"
+- **The TU header above func_80148E54 is now wrong.** It says "then jalr with no args" (the TU at line 749). The
+  handler takes the angle. The coordinator should correct it when banking.
+- With c3's sibling reading in hand, this closed on the second `--try`. The cross-function prediction was the method's
+  strongest step this time.
diff --git a/.run/P36/agents/ov_SC04_011__func_8015D738/body.c b/.run/P36/agents/ov_SC04_011__func_8015D738/body.c
index ef5ca696f6..c564549c21 100644
--- a/.run/P36/agents/ov_SC04_011__func_8015D738/body.c
+++ b/.run/P36/agents/ov_SC04_011__func_8015D738/body.c
@@ -7,12 +7,11 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0 && *(u16 *)s1 == 0x360) {
-        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
-        ((void (*)(void *))func_8015DAC4)(arg0);
-        return;
-    }
     if (s1 == 0 || *(u16 *)s1 == 0) {
         D_80192AC8[*(u16 *)arg0](arg0);
         ((void (*)(void *, s32))func_80147078)(arg0, 0);
@@ -20,6 +19,7 @@ void func_8015D738(void *arg0) {
         return;
     }
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
+    block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
         ((void (*)(void *))func_8015DAC4)(arg0);
         return;
diff --git a/.run/P36/agents/ov_SC04_011__func_8015D738/mechanism.md b/.run/P36/agents/ov_SC04_011__func_8015D738/mechanism.md
new file mode 100644
index 0000000000..662c5c431c
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_8015D738/mechanism.md
@@ -0,0 +1,86 @@
+# func_8015D738 (ov_SC04_011_jr_8015C32C.c) — T7 agent c5
+
+**Result: score 0 (201/201, byte-identical by `--try`), barrier lever gone, no pin, no asm, no volatile, no zero term.**
+`PACK/body.c` is the close. It carries ONE `do { … } while (0);` around a real statement (the first read of `arg0->0x178`).
+Please read "Verdict on the do-while" below before banking: whether that counts as a close is your call.
+
+## (a) The residual
+
+COUNTED first. The lever-free text is 4 instructions SHORT (197 vs 201), not a register problem: both `s1 != 0` tests collapse.
+The first `beqz s1` is retargeted past the second test, straight to the call block, and the second `lhu 0(s1)` is gone
+(`a1` reused). The target keeps both: the first `beqz s1` lands ON the second `beqz s1` (0x1470), and the second test reloads
+`lhu v0,0(s1)`.
+
+## (b) The pass and the decision (source read, then proved on bytes)
+
+- **thread_jumps** (`jump.c:4161`) runs twice: `toplev.c:2863` before cse1 and `toplev.c:2935` after cse2. It retargets b1
+  when b1 and b2 test `rtx_equal_for_thread_p` operands. REG case (`jump.c:4383-4410`): same regno and not written between
+  the label and b2 means equal. A different regno where either side is a user variable means NOT equal, and so does a
+  regno written in between (`mark_modified_reg`, `jump.c:4135`). The walk back from b2 (`jump.c:4270-4300`) also has to reach
+  b1's label through pattern-equal insns, so any differing insn in between stops the thread.
+  **Oracle (cookbook §353), 1 compile:** `body_free.c` with `-fno-thread-jumps` gives exactly the target's shape here. The
+  whole residual is thread_jumps. (PROVED)
+- **cse1 vs cse2.** `cse_end_of_basic_block` (`cse.c:8008`) takes b1 AROUND the lhu block into the second test's label
+  when that label has one use (`cse.c:8110-8175`). The `arg0->0x178` value comes along; the skipped block's lhu result is
+  invalidated. `cse.c:8054` (`if (! after_loop && NOTE_INSN_LOOP_END) break;`) ends cse1's path at a LOOP_END note, and
+  cse2 (`after_loop=1`, `toplev.c:2926`) walks straight through it. `delete_dead_from_cse` (`cse.c:8684`) runs after cse1
+  ONLY (`toplev.c:2867`), so nothing deletes a copy that cse2 turns dead or no-op before thread #2. Flow does that later. (PROVED
+  on dumps, `scratch/dumps_t3`, `scratch/dumps_t8`.)
+
+## (c) The moves (each proved with `--try`)
+
+1. **17 → 1: re-read the pointer before the second test.** `s1 = *(s32 *)(arg0 + 0x178);` (or the expression itself,
+   a fresh block-local, a ternary, a switch: v1/w2/b1/b2/b4/b5/c2/c4 all score 1). Thread #1 stops firing because b2 now
+   tests a fresh pseudo, or a written one. The second lhu comes back (201 = 201). But cse1, on the AROUND path, folds the
+   re-read into `s1`, `delete_dead_from_cse` removes the leftover, and thread #2 still threads b1 (the one remaining diff,
+   `beqz s1,1488` vs `1470`).
+2. **1 → 0: wrap the FIRST read in `do { … } while (0);`.** The LOOP_END note ends cse1's path before b1, so cse1 never
+   sees the re-read as redundant and leaves the real load (`.cse`: `(set (reg/v 74) (mem (plus 72 376)))` at the label).
+   cse2 walks through the note and rewrites it to the no-op `(set (reg/v 74) (reg/v 74))` (`.cse2`). Nothing deletes that
+   before thread #2, which sees reg 74 written between the label and b2 and refuses. Flow then deletes the no-op
+   (`.flow`: NOTE_INSN_DELETED). Result: one `lw`, both tests, the second lhu, and the register assignment unchanged.
+   `goto block_7F4` also goes: the second test is written as `if (s1 == 0 || *(u16 *)s1 == 0) { …; return; }`.
+
+## Verdict on the do-while (read before banking)
+
+`scratch/t3.c` puts an EMPTY `do { } while (0);` right after the load, and it is ALSO byte-identical. So the construct's only
+effect here is a cse1-only barrier: a LOOP_END note, the same job the `asm volatile("")` did by other means. `body.c`
+(t8) wraps a real statement (the load it guards), which is the shape project precedent banks. It is rung-R recipe R7
+(`do { stmt; } while (0);`), cookbook §158a, and the S102 a4/b8 closes, and levers.md classes A–G do not count it. I do
+not claim it is what the original author wrote. If the phase rules that a do-while whose whole effect is a barrier is a
+lever (METHOD refusal 6, "dummy dependency"), then the honest lever-free result is **score 1**: `scratch/v1.c`/`scratch/w2.c`,
+one branch target off, with the mechanism above. A disabled debug macro that expands to `do { } while (0)` right after the
+load is one plausible original, but it is not evidence.
+
+## (d) Generator proposal
+
+When the target has two back-to-back identical tests of one local (the first branch lands ON the second test, and the
+second test re-derives what the first already loaded) and the lever-free body is short by the second test's instructions,
+do this. Re-read the local from memory right before the second test. If that scores exactly one branch target off (thread
+#2 still fires), also wrap the local's FIRST assignment in `do { … } while (0);`. Check first with one `-fno-thread-jumps`
+compile: if the residual vanishes, this is the family.
+
+## (e) Tried, did not work (bytes)
+
+- w1, two variables (`t` for the first test, `s1` re-read for the second): the thread is blocked, but `t` gets `a1` and
+  `move s1,a1` survives (14). global.c propagates only hard-reg preferences. A pseudo-to-pseudo copy is not a preference
+  unless one side already has a hard reg (`expand_preferences` `global.c:781`, `set_preference` `:1535`).
+- w3, an unused label before the second test: jump deletes it (17).
+- t1, `do-while(0)` around the FIRST TEST: the if's exit jump is threaded to the loop-exit label, and the AROUND path skips
+  the note. Still threaded, plus an s0/s1 swap from loop-depth ref weighting (56).
+- t4, `do-while(0)` around the whole prologue: 6 (ORDER; loop weighting).
+- t6, plain block `{ s1 = load; }`: 1 (BLOCK notes do not stop cse).
+- t9, the A body written out in place instead of `goto block_808`: count right, but the two extra `arg0` refs swap s0/s1 (56).
+- c1/c3, re-reading in BOTH tests: 87. b6/b7, a ternary on `s1`: 17.
+
+## (f) Where the method fell short
+
+- The residual printout read as a register residual (`a1->v1`) plus branch targets. Only counting (197 vs 201) and
+  the whole-function objdump showed a missing TEST. METHOD step 2 is right, and it should come before the register-pair line.
+- `residual_moves.md` has no thread_jumps row. The cheapest diagnosis was cookbook §353's `-fno-thread-jumps` oracle:
+  one compile named the pass. It belongs in METHOD step 3's list ("a missing re-test = run the per-pass disable flag first").
+- The pack's `scratch/score.sh` (left by an earlier run) cd's before resolving a relative path, so every call died with a
+  traceback. My `scratch/sc.sh` resolves the path first.
+- `delever_search`'s moves (R7 block / do-while at @2003, @1972, @1960, @1949) never put a do-while on the LOAD (@1952), and
+  never paired it with a re-read. This close is a JOINT edit: the re-read alone gives 1, and the do-while alone gives 17
+  (scratch/t10.c, PROVED), because thread #1 already fires before cse1.
diff --git a/.run/P36/agents/ov_SC04_011__func_801670E4/body.c b/.run/P36/agents/ov_SC04_011__func_801670E4/body.c
new file mode 100644
index 0000000000..d058b5fa1b
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_801670E4/body.c
@@ -0,0 +1,149 @@
+s32 func_801670E4(s32 arg0, s32 arg1, s32 arg2, s32 arg3) {
+
+    extern u8  D_80193330[];
+    extern u8  D_8019331C[];
+    extern u8  D_80193344[];
+    extern s32 D_801269A4;
+    extern s32 D_801269A8;
+    extern s32 D_801269AC;
+    extern u16 D_80126CE0;
+    Fr_801670E4 f;
+    u8 *p;   /* $s2 */
+    s32 ent;   /* $s3 */
+    s16 i;
+    s32 d;
+    s32 node;
+    u16 c;
+    u8 cv;
+    u8 cv2;
+    s32 gA;
+    s32 cxv;
+    s32 czv;
+    u8 *vc;
+    u8 *ap;
+    u8 *mp;
+    u8 *va;
+    u8 *vb;
+
+    ent = arg0;
+    node = *(s32 *)(ent + 0x34);
+    f.v[1].z = 0;
+    f.v[1].y = 0;
+    f.v[1].x = 0;
+    f.v[3].z = 0;
+    f.v[2].z = 0;
+    f.v[0].z = 0;
+    f.col[1].b = 0x70;
+    cv = *(u8 *)(ent + 0x12);
+    f.cx = arg1;
+    va = (u8 *)&f.cx;
+    f.cy = arg2;
+    vb = va;
+    p = D_80193330;
+    i = 0;
+    f.col[0].b = 0;
+    f.col[0].g = 0;
+    f.col[0].r = 0;
+    f.col[2].b = 0;
+    f.col[2].g = 0;
+    f.col[2].r = 0;
+    f.col[3].b = 0;
+    f.col[3].g = 0;
+    f.col[3].r = 0;
+    f.code = 0x50000000;
+    f.cz = arg3;
+    f.col[1].r = cv;
+    f.col[1].g = cv;
+    ((void (*)(s32, void *, void *))func_80149350)(node, va, vb);
+
+    c = f.cx;
+    *(s16 *)(ent + 0x06) = c;
+    *(s32 *)(ent + 0x4C) = (s16)c;
+    c = f.cy;
+    *(s16 *)(ent + 0x0A) = c;
+    *(s32 *)(ent + 0x50) = (s16)c;
+    c = f.cz;
+    *(s16 *)(ent + 0x0E) = c;
+    *(s32 *)(ent + 0x54) = (s16)c;
+    func_800D20C0(&f.cx, f.a8, 7);
+    func_80017E68(&f.cx, f.m1);
+    func_800D23D0(f.a8);
+    RotMatrixYXZ(f.a8, f.m1);
+
+    do {
+        f.v[0].x = (s8)*p++;
+        f.v[0].y = (s8)*p++;
+        f.v[2].x = (s8)*p++;
+        f.v[2].y = (s8)*p++;
+        f.v[3].x = (s8)*p++;
+        f.v[3].y = (s8)*p--;
+        func_80017758(f.v, f.m1);
+    } while ((i = i + 1) < 4);
+
+    p = D_8019331C;
+    gA = 0xA0;
+    cxv = (s16)f.cx;
+    f.col[1].g = gA;
+    gA = D_801269A4;
+    czv = (s16)f.cz;
+    f.col[1].b = 0x10;
+    f.col[1].r = 0x10;
+    f.pos[0] = gA - cxv;
+    i = 0;
+    f.v[3].y = 0;
+    f.v[2].y = 0;
+    f.v[0].y = 0;
+    f.pos[1] = D_801269A8 - (s16)f.cy;
+    f.pos[2] = D_801269AC - czv;
+
+    do {
+        f.v[0].x = (s8)*p++;
+        f.v[0].z = (s8)*p++;
+        f.v[2].x = (s8)*p++;
+        f.v[2].z = (s8)*p++;
+        f.v[3].x = (s8)*p++;
+        f.v[3].z = (s8)*p--;
+        func_80017758(f.v, (void *)(ent + 0x38));
+    } while ((i = i + 1) < 4);
+
+    if (*(s32 *)(ent + 0x30) > 0) {
+        vc = (u8 *)&f.cx;
+        mp = f.m1;
+        ap = mp;
+        p = D_80193344;
+        i = 0;
+        d = (s16)f.a8[0] >> 6;
+        f.cx += d;
+        f.cy += d;
+        f.cz += d;
+        func_80017E68(vc, ap);
+        f.cx = f.cy = f.cz = ((u32)*(s32 *)(ent + 0x30) >> 1) + D_80126CE0 * 0x20;
+        func_80017DC4(&f.cx, f.m2);
+        func_80048EAC(f.m2, mp);
+        f.v[3].z = 0;
+        f.v[2].z = 0;
+        f.v[0].z = 0;
+        cv2 = *(u8 *)(ent + 0x12);
+        f.col[1].b = 0x20;
+        f.col[1].r = 0x20;
+        f.col[3].b = 0;
+        f.col[3].r = 0;
+        f.col[2].b = 0;
+        f.col[2].r = 0;
+        f.col[0].b = 0;
+        f.col[0].r = 0;
+        f.col[3].g = 0;
+        f.col[2].g = 0;
+        f.col[0].g = 0;
+        f.col[1].g = cv2 + 0x60;
+        do {
+            f.v[0].x = (s8)*p++;
+            f.v[0].y = (s8)*p++;
+            f.v[2].x = (s8)*p++;
+            f.v[2].y = (s8)*p++;
+            f.v[3].x = (s8)*p++;
+            f.v[3].y = (s8)*p--;
+            func_80017758(f.v, f.m1);
+        } while ((i = i + 1) < 8);
+    }
+}
diff --git a/.run/P36/agents/ov_SC04_011__func_80175AB8/body.c b/.run/P36/agents/ov_SC04_011__func_80175AB8/body.c
new file mode 100644
index 0000000000..3c065d5dab
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_80175AB8/body.c
@@ -0,0 +1,85 @@
+void func_80175AB8(param_1)
+    s16 param_1;
+{
+   /* size 0x0C */
+    extern S_AF634 D_800AF634[];
+    extern S_AF634 D_800AF638[];
+
+    extern u8  D_8011F7F0;
+    extern u16 D_8011F7B4;
+    extern u16 D_8011F7B6;
+    extern s16 D_8011F7BC;
+    extern s16 D_8011F7BE;
+    extern s32 D_8011F804;
+    extern u16 D_8011F80A;
+    extern u16 D_8011F824;
+    extern u8  D_8011F832;
+    extern u8  D_8011F83A;
+    extern u8 *D_80193B4C[];
+
+    extern u32 *func_80176D94(void *param_1, u32 param_2, s16 param_3_);
+    extern u32 *func_801770E0(void *param_1, u32 param_2, s16 param_3_);
+    extern u32  func_801783D0(s32 a0, s32 a1);
+    extern u32 *func_80177EA4(u32 *param_1, s32 param_2, u32 param_3, s32 param_4);
+    extern u32 *func_80177B5C(u32 *a0, s32 a1, s32 a2, s32 a3, s32 a4);
+    extern void func_80177940(u32 *p, u32 a_, u32 b_, u32 c_);
+    extern u32 *func_80178298(u32 *param_1, u8 *param_2, short param_3, short param_4);
+    extern s32 func_80024054(u8*, u8*);
+    extern s32  func_8005A600(s32, s32, s32, s32, s32);
+
+    u8 local[24];
+    u8 *base;
+    u8 *arr;
+    u32 *slot;
+    u32 *p;
+    u32 *a0v;
+    u32 uv;
+    s32 k;
+    s16 q;
+    s32 r1;
+    s32 a2v;
+    s32 sum;
+    s32 r2;
+    s32 idx;
+    s16 sv;
+
+    p = (u32 *)(D_800AF638[param_1].g0 + D_800AF634[param_1].g0 * 4);
+    base = &D_8011F7F0;
+    arr = base - 0x48;
+    slot = (u32 *)(param_1 * 4 + (s32)arr);
+    *(volatile u32 *)&slot[6] = (u32)p;                        /* L2 */
+    p = func_80176D94(p, (s16)(D_8011F7B4 - 0x71), (s16)(D_8011F7B6 + 0x51));
+    p = func_801770E0(p, (s16)(D_8011F7B4 - 0x71), (s16)(D_8011F7B6 + 0x65));
+    p = func_80177EA4(p, func_801783D0(D_8011F804, 0),
+                      (s16)((*(u16 *)&D_8011F7BC) + 0x39), (s16)((*(u16 *)&D_8011F7BE) + 0x51));
+    uv = D_8011F824;
+    k = 0x3E7;
+    if (uv < 1000) {
+        k = uv;
+    }
+    sv = (s16)func_801783D0(k, 4);
+    p = func_80177B5C(p, sv, D_8011F832,
+                      (s16)(*(u16 *)(base - 0x34) + 0x39),
+                      (s16)(*(u16 *)(base - 0x32) + 0x65));
+    q = (s16)D_8011F80A / 15;
+    a2v = (q & 3) * 15;
+    r1 = func_801783D0((s32)(q << 16) >> 18, 8);
+    r2 = func_801783D0(a2v, 0);
+    a0v = p;                                                   /* L4 */
+    sum = r1 + r2;                                             /* L3 */
+    p = ((u32 * (*)(u32 *, s32, s32, s32))func_80177940)(
+            a0v, (s16)sum,
+            (s16)(*(u16 *)(base - 0x34) + 0x76),
+            (s16)(*(u16 *)(base - 0x32) + 0x65));
+    idx = D_8011F83A & 0x7F;
+    D_8011F83A = idx;
+    func_80024054(*(u8 **)((u8 *)D_80193B4C + idx * 4), local);
+    p = func_80178298(p, local,
+                      (s16)(*(u16 *)(base - 0x34) + 0x39),
+                      (s16)(*(u16 *)(base - 0x32) + 0x5B));
+    func_8005A600((s32)p, 0, 0, 0x15, 0);
+    *p = (((u32)p - 0x14) & 0xFFFFFF) | 0x2000000;
+    slot[8] = (u32)p;
+    p += 5;
+    D_800AF634[param_1].g0 += ((s32)p - (s32)slot[6]) >> 2;
+}
diff --git a/.run/P36/agents/ov_SC04_011__func_80175AB8/mechanism.md b/.run/P36/agents/ov_SC04_011__func_80175AB8/mechanism.md
new file mode 100644
index 0000000000..5299ec5bc2
--- /dev/null
+++ b/.run/P36/agents/ov_SC04_011__func_80175AB8/mechanism.md
@@ -0,0 +1,14 @@
+# func_80175AB8 (ov_SC04_011) — T7 agent c11 — WORK IN PROGRESS
+
+Start: lever-free score 41 (mine 191 / target 188). Three independent residuals:
+(A) &D_8011F7F0 held in $s2 all function (target) vs folded to absolute addresses (mine) — the launder lever.
+(B) (s16)(r1 + r2) computed in $a1 (target) vs in $s0 (mine) — the $4/$5 pins.
+(C) D_80193B4C[idx] load hoisted by sched1 above the `D_8011F83A = idx` store (mine) — the memory barrier.
+
+(C) CLOSED (score 41 -> 33 on the lever-free body; with launder kept, 11 -> 3):
+  `func_80024054(*(u8 **)((u8 *)D_80193B4C + idx * 4), local);`
+  expr.c:4568-4575 (expand_expr INDIRECT_REF) sets MEM_IN_STRUCT_P when the INDIRECT_REF operand is a PLUS_EXPR;
+  `p[i]` is *(p+i) so the table load is /s with a varying address, the scalar store is not /s with a fixed address,
+  and sched.c true_dependence's in-struct exclusion declares them independent -> sched1 hoists the load over the store.
+  Wrapping the pointer arithmetic in a cast makes the operand a NOP_EXPR, the load is not /s, memrefs_conflict_p
+  answers "conflict" for (plus reg sym) vs sym, and the load stays after the store.
diff --git a/.run/P36/census/lever_census.json b/.run/P36/census/lever_census.json
index 06ade9fcb3..036b2075bb 100644
--- a/.run/P36/census/lever_census.json
+++ b/.run/P36/census/lever_census.json
@@ -38,7 +38,7 @@
    ".section": 7,
    "RTP_SND": 22,
    "addiu": 22,
-   "addu": 834,
+   "addu": 432,
    "and": 2,
    "la": 142,
    "lh": 134,
@@ -54,17 +54,17 @@
   },
   "kinds": {
    "asm-body/direct": 13,
-   "barrier/direct": 3561,
+   "barrier/direct": 3177,
    "barrier/via-macro": 2,
    "gte-lever/direct": 362,
    "gte-lever/via-macro": 100,
    "gte-unsigned/direct": 3,
    "gte/direct": 200,
    "gte/via-macro": 6658,
-   "instruction/direct": 1177,
+   "instruction/direct": 775,
    "instruction/via-macro": 22,
-   "keepalive/direct": 1317,
-   "launder/direct": 3242,
+   "keepalive/direct": 930,
+   "launder/direct": 3110,
    "launder/via-macro": 444,
    "verbatim-body/direct": 2682
   }
@@ -72,37 +72,37 @@
  "binaries": 218,
  "classes": {
   "A": {
-   "bodies": 5145,
-   "distinct_bodies": 952,
+   "bodies": 4362,
+   "distinct_bodies": 946,
    "file_scope": 0,
-   "in_bodies": 13748,
+   "in_bodies": 11271,
    "kinds": {
-    "pin": 13748
+    "pin": 11271
    },
-   "marked": 13748,
-   "sites": 13748,
-   "tus": 2079,
+   "marked": 11271,
+   "sites": 11271,
+   "tus": 2071,
    "unmarked": 0
   },
   "B": {
-   "bodies": 7352,
-   "distinct_bodies": 904,
+   "bodies": 6573,
+   "distinct_bodies": 898,
    "file_scope": 13,
-   "in_bodies": 19770,
+   "in_bodies": 18465,
    "kinds": {
     "asm-body": 13,
-    "barrier": 3563,
+    "barrier": 3179,
     "gte": 6858,
     "gte-lever": 462,
     "gte-unsigned": 3,
-    "instruction": 1199,
-    "keepalive": 1317,
-    "launder": 3686,
+    "instruction": 797,
+    "keepalive": 930,
+    "launder": 3554,
     "verbatim-body": 2682
    },
-   "marked": 10506,
-   "sites": 19783,
-   "tus": 1980,
+   "marked": 9201,
+   "sites": 18478,
+   "tus": 1972,
    "unmarked": 9277
   },
   "C": {
@@ -207,9 +207,9 @@
  "coverage": {
   "asm": {
    "comment_dead": 6792,
-   "live": 34147,
+   "live": 30365,
    "macro_block": 194,
-   "raw": 41133
+   "raw": 37351
   },
   "attribute": {
    "comment_dead": 0,
@@ -225,9 +225,9 @@
   },
   "register": {
    "comment_dead": 8587,
-   "live": 13798,
+   "live": 11321,
    "macro_block": 18,
-   "raw": 22403
+   "raw": 19926
   },
   "volatile": {
    "comment_dead": 2480,
@@ -237,7 +237,7 @@
   }
  },
  "coverage_ok": true,
- "elapsed_s": 24.0,
+ "elapsed_s": 25.1,
  "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": "82da34b39",
+ "head": "205331765",
  "headers": 3181,
  "levers_AB": {
-  "asm": 10240,
-  "bodies": 6186,
-  "distinct_bodies": 1256,
-  "marked": 23988,
-  "pins": 13748,
-  "sites": 23988,
+  "asm": 8935,
+  "bodies": 5277,
+  "distinct_bodies": 1249,
+  "marked": 20206,
+  "pins": 11271,
+  "sites": 20206,
   "unmarked": 0,
   "what": "register pins + asm statements excluding GTE ops: the classes the phase drives to 0"
  },
@@ -390,9 +390,9 @@
  },
  "pins": {
   "bare_name": 15,
-  "init": 1243,
+  "init": 849,
   "registers": {
-   "$0": 385,
+   "$0": 117,
    "$10": 144,
    "$11": 5,
    "$12": 280,
@@ -401,52 +401,52 @@
    "$15": 1,
    "$16": 576,
    "$17": 363,
-   "$18": 180,
-   "$19": 438,
-   "$2": 2614,
+   "$18": 46,
+   "$19": 308,
+   "$2": 2350,
    "$20": 284,
    "$21": 273,
    "$22": 7,
    "$23": 144,
    "$25": 1,
    "$29": 13,
-   "$3": 1790,
-   "$4": 2153,
-   "$5": 2177,
-   "$6": 470,
-   "$7": 578,
-   "$8": 429,
-   "$9": 283,
+   "$3": 1268,
+   "$4": 1885,
+   "$5": 2045,
+   "$6": 217,
+   "$7": 452,
+   "$8": 176,
+   "$9": 156,
    "7": 1,
    "a0": 7,
    "a1": 2,
    "v0": 2,
    "v1": 3
   },
-  "sites": 13748,
+  "sites": 11271,
   "sp": 13,
   "spelling": {
-   "__asm__": 13670,
+   "__asm__": 11193,
    "asm": 78
   },
   "volatile_qualified": 7,
-  "zero": 385
+  "zero": 117
  },
- "src_stamp": "674ac8f02e665a6e",
+ "src_stamp": "30843f2387f96cff",
  "tus": 4121,
  "unclassified": 0,
  "union_AD": {
-  "bodies": 9449,
+  "bodies": 8540,
   "by_kind": {
    "main": 165,
    "md": 135,
-   "ov": 8922,
+   "ov": 8023,
    "resident": 10,
-   "shared": 217
+   "shared": 207
   },
-  "copies_in_multi": 8186,
-  "distinct_bodies": 1541,
-  "multi_copy_classes": 278
+  "copies_in_multi": 7277,
+  "distinct_bodies": 1534,
+  "multi_copy_classes": 271
  },
  "verbatim_excluded": {
   "functions": 13,
diff --git a/.run/P36/census/lever_census.txt b/.run/P36/census/lever_census.txt
index a667f9e87f..80150c3937 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  41133 = live  34147 + macro-block   194 + comment/dead  6792
-  coverage register  raw  22403 = live  13798 + macro-block    18 + comment/dead  8587
+  coverage asm       raw  37351 = live  30365 + macro-block   194 + comment/dead  6792
+  coverage register  raw  19926 = live  11321 + macro-block    18 + comment/dead  8587
   coverage volatile  raw   4456 = live   1894 + macro-block    82 + comment/dead  2480
   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        13748     13748          0    5145       952  2079   13748         0   {'pin': 13748}
-  B asm         19783     19770         13    7352       904  1980   10506      9277   {'instruction': 1199, 'barrier': 3563, 'launder': 3686, 'gte': 6858, 'keepalive': 1317, 'gte-lever': 462, 'gte-unsigned': 3, 'asm-body': 13, 'verbatim-body': 2682}
-  C volatile     1590      1438        152     496        96   610      14      1576   {'decl-body': 58, 'decl-file': 152, 'cast': 1378, 'param': 2}
+  A pins        11271     11271          0    4362       946  2071   11271         0   {'pin': 11271}
+  B asm         18478     18465         13    6573       898  1972    9201      9277   {'instruction': 797, 'keepalive': 930, 'gte': 6858, 'barrier': 3179, 'verbatim-body': 2682, 'launder': 3554, 'gte-lever': 462, 'gte-unsigned': 3, 'asm-body': 13}
+  C volatile     1590      1438        152     496        96   610      14      1576   {'cast': 1378, 'decl-body': 58, 'decl-file': 152, 'param': 2}
   D register       50        50          0      47        47     6       0        50   {'register': 50}
   E asm-label    7680      1257       6423     989       119  2084       0      7680   {'asm-label': 7680}
   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: 9,449 bodies · 1,541 distinct (addresses normalized) · 278 multi-copy classes holding 8,186 bodies · by kind {'ov': 8922, 'main': 165, 'md': 135, 'shared': 217, 'resident': 10}
-  THE PHASE'S NUMBER (pins + asm statements, GTE excluded): 23,988 sites in 6,186 bodies (1,256 distinct) · marked !FAKE 23,988 · UNMARKED 0
+  UNION A–D: 8,540 bodies · 1,534 distinct (addresses normalized) · 271 multi-copy classes holding 7,277 bodies · by kind {'ov': 8023, 'shared': 207, 'main': 165, 'md': 135, 'resident': 10}
+  THE PHASE'S NUMBER (pins + asm statements, GTE excluded): 20,206 sites in 5,277 bodies (1,249 distinct) · marked !FAKE 20,206 · 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, 'launder': 154, 'instruction': 9, 'barrier': 1} (GTE variants 64)
-  pins: 13,748 · $0 385 · $sp 13 · with initializer 1,243 · volatile-qualified 7 · bare-name 15 · spellings {'__asm__': 13670, 'asm': 78}
+  per-TU asm macro definitions outside the GTE header: 314 {'launder': 154, 'gte': 150, 'instruction': 9, 'barrier': 1} (GTE variants 64)
+  pins: 11,271 · $0 117 · $sp 13 · with initializer 849 · volatile-qualified 7 · bare-name 15 · spellings {'__asm__': 11193, 'asm': 78}
   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': 3561, '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': 1177, 'instruction/via-macro': 22, 'keepalive/direct': 1317, 'launder/direct': 3242, 'launder/via-macro': 444, 'verbatim-body/direct': 2682}
-  instruction mnemonics: {'addu': 834, 'la': 142, 'lh': 134, 'move': 25, 'addiu': 22, 'RTP_SND': 22, '.section': 7, 'lui': 4, '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_ldIR0z': 134, 'gte_ldIRGB': 134, 'gte_dpcl': 134, 'gte_stORGB': 134, 'gte_stszotz': 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, 'launder': 154, 'instruction': 9, 'barrier': 1}
+  asm kinds: {'asm-body/direct': 13, 'barrier/direct': 3177, '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': 775, 'instruction/via-macro': 22, 'keepalive/direct': 930, 'launder/direct': 3110, 'launder/via-macro': 444, 'verbatim-body/direct': 2682}
+  instruction mnemonics: {'addu': 432, 'la': 142, 'lh': 134, 'move': 25, 'addiu': 22, 'RTP_SND': 22, '.section': 7, 'lui': 4, '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 {'launder': 154, 'gte': 150, '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 24.0 s
+  elapsed 25.1 s
diff --git a/.run/P36/delever/calibration.json b/.run/P36/delever/calibration.json
index 8c558f719e..a6fc598066 100644
--- a/.run/P36/delever/calibration.json
+++ b/.run/P36/delever/calibration.json
@@ -1,7 +1,7 @@
 {
- "head": "82da34b39",
- "stamp": "b44c5a8a3423",
- "generated": "2026-09-10 14:16",
+ "head": "205331765",
+ "stamp": "15956e4a96c4",
+ "generated": "2026-09-10 14:44",
  "aliases": [
   "main",
   "ov_SC03_014",
@@ -21,207 +21,207 @@
   "main": {
    "objects": 85,
    "identical": 85,
-   "seconds": 7.242,
-   "mean_s": 0.085
+   "seconds": 6.663999999999996,
+   "mean_s": 0.078
   },
   "ov_SC03_014": {
    "objects": 32,
    "identical": 32,
-   "seconds": 4.7650000000000015,
-   "mean_s": 0.149
+   "seconds": 4.655999999999999,
+   "mean_s": 0.145
   },
   "ov_SC03_015": {
    "objects": 32,
    "identical": 32,
-   "seconds": 4.612000000000001,
-   "mean_s": 0.144
+   "seconds": 4.455000000000001,
+   "mean_s": 0.139
   },
   "ov_SC04_011": {
    "objects": 28,
    "identical": 28,
-   "seconds": 3.9710000000000005,
-   "mean_s": 0.142
+   "seconds": 3.835,
+   "mean_s": 0.137
   }
  },
  "per_object_seconds": {
-  "build/src/800.o": 0.734,
-  "build/src/800_b.o": 0.081,
-  "build/src/800_b_2.o": 0.304,
-  "build/src/800_b_o0a.o": 0.074,
-  "build/src/800_c.o": 0.202,
-  "build/src/800b2.o": 0.096,
-  "build/src/apicard1.o": 0.068,
-  "build/src/apicard2.o": 0.072,
-  "build/src/apicard3.o": 0.082,
-  "build/src/apicard4.o": 0.082,
-  "build/src/apicard5.o": 0.082,
+  "build/src/800.o": 0.739,
+  "build/src/800_b.o": 0.096,
+  "build/src/800_b_2.o": 0.276,
+  "build/src/800_b_o0a.o": 0.069,
+  "build/src/800_c.o": 0.173,
+  "build/src/800b2.o": 0.075,
+  "build/src/apicard1.o": 0.059,
+  "build/src/apicard2.o": 0.059,
+  "build/src/apicard3.o": 0.073,
+  "build/src/apicard4.o": 0.067,
+  "build/src/apicard5.o": 0.079,
   "build/src/apicard6.o": 0.068,
-  "build/src/apicard7.o": 0.08,
-  "build/src/boot.o": 0.108,
-  "build/src/gap.o": 0.083,
-  "build/src/libapi1.o": 0.102,
-  "build/src/libapi2.o": 0.072,
+  "build/src/apicard7.o": 0.07,
+  "build/src/boot.o": 0.103,
+  "build/src/gap.o": 0.065,
+  "build/src/libapi1.o": 0.078,
+  "build/src/libapi2.o": 0.061,
   "build/src/libc2_1.o": 0.066,
-  "build/src/libc2_2.o": 0.066,
-  "build/src/libcd1.o": 0.079,
-  "build/src/libcd2.o": 0.072,
-  "build/src/libetc.o": 0.072,
-  "build/src/libgpu.o": 0.077,
-  "build/src/libgpu2.o": 0.075,
-  "build/src/libgs1.o": 0.069,
-  "build/src/libgs2.o": 0.072,
-  "build/src/libgs3.o": 0.079,
-  "build/src/libgs4.o": 0.072,
-  "build/src/libgs5.o": 0.069,
-  "build/src/libgs6.o": 0.081,
-  "build/src/libgs7.o": 0.071,
-  "build/src/libgs8.o": 0.063,
-  "build/src/libgte1.o": 0.069,
-  "build/src/libgte10.o": 0.066,
-  "build/src/libgte11.o": 0.069,
-  "build/src/libgte12.o": 0.062,
-  "build/src/libgte13.o": 0.068,
-  "build/src/libgte14.o": 0.068,
-  "build/src/libgte15.o": 0.062,
-  "build/src/libgte16.o": 0.062,
-  "build/src/libgte17.o": 0.066,
-  "build/src/libgte18.o": 0.066,
-  "build/src/libgte19.o": 0.067,
-  "build/src/libgte2.o": 0.064,
-  "build/src/libgte20.o": 0.068,
-  "build/src/libgte21.o": 0.066,
-  "build/src/libgte22.o": 0.076,
-  "build/src/libgte23.o": 0.07,
-  "build/src/libgte24.o": 0.079,
-  "build/src/libgte25.o": 0.073,
-  "build/src/libgte26.o": 0.084,
-  "build/src/libgte27.o": 0.071,
-  "build/src/libgte28.o": 0.066,
-  "build/src/libgte29.o": 0.062,
-  "build/src/libgte3.o": 0.072,
+  "build/src/libc2_2.o": 0.061,
+  "build/src/libcd1.o": 0.069,
+  "build/src/libcd2.o": 0.061,
+  "build/src/libetc.o": 0.064,
+  "build/src/libgpu.o": 0.057,
+  "build/src/libgpu2.o": 0.08,
+  "build/src/libgs1.o": 0.06,
+  "build/src/libgs2.o": 0.057,
+  "build/src/libgs3.o": 0.059,
+  "build/src/libgs4.o": 0.06,
+  "build/src/libgs5.o": 0.061,
+  "build/src/libgs6.o": 0.071,
+  "build/src/libgs7.o": 0.061,
+  "build/src/libgs8.o": 0.061,
+  "build/src/libgte1.o": 0.068,
+  "build/src/libgte10.o": 0.062,
+  "build/src/libgte11.o": 0.06,
+  "build/src/libgte12.o": 0.057,
+  "build/src/libgte13.o": 0.063,
+  "build/src/libgte14.o": 0.063,
+  "build/src/libgte15.o": 0.069,
+  "build/src/libgte16.o": 0.064,
+  "build/src/libgte17.o": 0.063,
+  "build/src/libgte18.o": 0.057,
+  "build/src/libgte19.o": 0.062,
+  "build/src/libgte2.o": 0.06,
+  "build/src/libgte20.o": 0.061,
+  "build/src/libgte21.o": 0.077,
+  "build/src/libgte22.o": 0.058,
+  "build/src/libgte23.o": 0.061,
+  "build/src/libgte24.o": 0.065,
+  "build/src/libgte25.o": 0.063,
+  "build/src/libgte26.o": 0.063,
+  "build/src/libgte27.o": 0.066,
+  "build/src/libgte28.o": 0.069,
+  "build/src/libgte29.o": 0.068,
+  "build/src/libgte3.o": 0.065,
   "build/src/libgte30.o": 0.068,
-  "build/src/libgte4.o": 0.071,
-  "build/src/libgte5.o": 0.069,
-  "build/src/libgte6.o": 0.073,
-  "build/src/libgte7.o": 0.075,
-  "build/src/libgte8.o": 0.076,
-  "build/src/libgte9.o": 0.092,
-  "build/src/libmcrd1.o": 0.085,
-  "build/src/libmcrd2.o": 0.067,
-  "build/src/libpad1.o": 0.085,
-  "build/src/libpad2.o": 0.081,
-  "build/src/sgap.o": 0.08,
-  "build/src/sgap_2.o": 0.091,
-  "build/src/sgap_3.o": 0.07,
-  "build/src/sgap_4.o": 0.076,
-  "build/src/sgap_5.o": 0.065,
-  "build/src/sgap_6.o": 0.062,
-  "build/src/sgap_8.o": 0.072,
-  "build/src/snd1.o": 0.073,
-  "build/src/snd10.o": 0.063,
+  "build/src/libgte4.o": 0.062,
+  "build/src/libgte5.o": 0.067,
+  "build/src/libgte6.o": 0.062,
+  "build/src/libgte7.o": 0.061,
+  "build/src/libgte8.o": 0.066,
+  "build/src/libgte9.o": 0.063,
+  "build/src/libmcrd1.o": 0.076,
+  "build/src/libmcrd2.o": 0.069,
+  "build/src/libpad1.o": 0.064,
+  "build/src/libpad2.o": 0.068,
+  "build/src/sgap.o": 0.061,
+  "build/src/sgap_2.o": 0.065,
+  "build/src/sgap_3.o": 0.06,
+  "build/src/sgap_4.o": 0.079,
+  "build/src/sgap_5.o": 0.064,
+  "build/src/sgap_6.o": 0.076,
+  "build/src/sgap_8.o": 0.071,
+  "build/src/snd1.o": 0.074,
+  "build/src/snd10.o": 0.061,
   "build/src/snd11.o": 0.069,
-  "build/src/snd12.o": 0.068,
-  "build/src/snd2.o": 0.071,
-  "build/src/snd3.o": 0.066,
-  "build/src/snd4.o": 0.074,
+  "build/src/snd12.o": 0.063,
+  "build/src/snd2.o": 0.085,
+  "build/src/snd3.o": 0.084,
+  "build/src/snd4.o": 0.083,
   "build/src/snd5.o": 0.066,
-  "build/src/snd6.o": 0.075,
-  "build/src/snd7.o": 0.07,
-  "build/src/snd8.o": 0.07,
-  "build/src/snd9.o": 0.07,
-  "build/src/ov_SC03_014/ov_SC03_014.o": 0.139,
-  "build/src/ov_SC03_014/ov_SC03_014_after.o": 0.507,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o": 0.389,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_80135888.o": 0.064,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_80135A4C.o": 0.064,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_80135D20.o": 0.118,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_801380E0.o": 0.161,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_8013C98C.o": 0.121,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_8013F350.o": 0.086,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_8013FFD8.o": 0.074,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_80140608.o": 0.183,
+  "build/src/snd6.o": 0.069,
+  "build/src/snd7.o": 0.062,
+  "build/src/snd8.o": 0.056,
+  "build/src/snd9.o": 0.068,
+  "build/src/ov_SC03_014/ov_SC03_014.o": 0.128,
+  "build/src/ov_SC03_014/ov_SC03_014_after.o": 0.499,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o": 0.392,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_80135888.o": 0.059,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_80135A4C.o": 0.06,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_80135D20.o": 0.122,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_801380E0.o": 0.164,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_8013C98C.o": 0.119,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_8013F350.o": 0.077,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_8013FFD8.o": 0.069,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_80140608.o": 0.187,
   "build/src/ov_SC03_014/ov_SC03_014_jr_8015444C.o": 0.073,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_80154C24.o": 0.176,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_801588CC.o": 0.096,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_80159C84.o": 0.076,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_8015A3C8.o": 0.075,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_8015AE2C.o": 0.106,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.o": 0.471,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_8016AB6C.o": 0.278,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_80171B4C.o": 0.103,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_801734BC.o": 0.207,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_801789AC.o": 0.068,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_80178D40.o": 0.11,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_8017A4AC.o": 0.073,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_8017AE2C.o": 0.181,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_80154C24.o": 0.171,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_801588CC.o": 0.093,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_80159C84.o": 0.074,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_8015A3C8.o": 0.078,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_8015AE2C.o": 0.097,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.o": 0.481,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_8016AB6C.o": 0.254,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_80171B4C.o": 0.096,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_801734BC.o": 0.211,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_801789AC.o": 0.06,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_80178D40.o": 0.101,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_8017A4AC.o": 0.066,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_8017AE2C.o": 0.158,
   "build/src/ov_SC03_014/ov_SC03_014_jr_8017EB7C.o": 0.197,
-  "build/src/ov_SC03_014/ov_SC03_014_jr_80184440.o": 0.056,
+  "build/src/ov_SC03_014/ov_SC03_014_jr_80184440.o": 0.052,
   "build/src/ov_SC03_014/ov_SC03_014_jr_801848E4.o": 0.278,
-  "build/src/ov_SC03_014/ov_SC03_014_o0b.o": 0.061,
+  "build/src/ov_SC03_014/ov_SC03_014_o0b.o": 0.051,
   "build/src/ov_SC03_014/ov_SC03_014_o0c.o": 0.057,
-  "build/src/ov_SC03_014/ov_SC03_014_o0d.o": 0.056,
-  "build/src/ov_SC03_014/ov_SC03_014_o0e.o": 0.061,
-  "build/src/ov_SC03_015/ov_SC03_015.o": 0.124,
-  "build/src/ov_SC03_015/ov_SC03_015_after.o": 0.52,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o": 0.396,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_80135888.o": 0.057,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_80135A4C.o": 0.055,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_80135D20.o": 0.12,
+  "build/src/ov_SC03_014/ov_SC03_014_o0d.o": 0.061,
+  "build/src/ov_SC03_014/ov_SC03_014_o0e.o": 0.071,
+  "build/src/ov_SC03_015/ov_SC03_015.o": 0.115,
+  "build/src/ov_SC03_015/ov_SC03_015_after.o": 0.493,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o": 0.368,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_80135888.o": 0.05,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_80135A4C.o": 0.048,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_80135D20.o": 0.11,
   "build/src/ov_SC03_015/ov_SC03_015_jr_801380E0.o": 0.151,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_8013C98C.o": 0.111,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_8013F350.o": 0.07,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_8013FFD8.o": 0.069,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_80140608.o": 0.173,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_8015444C.o": 0.068,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_80154C24.o": 0.173,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_801588CC.o": 0.082,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_80159C84.o": 0.068,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_8015A3C8.o": 0.067,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_8015AE2C.o": 0.093,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_8015C32C.o": 0.465,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_8016AB6C.o": 0.276,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_8013C98C.o": 0.103,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_8013F350.o": 0.083,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_8013FFD8.o": 0.063,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_80140608.o": 0.177,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_8015444C.o": 0.072,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_80154C24.o": 0.162,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_801588CC.o": 0.089,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_80159C84.o": 0.065,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_8015A3C8.o": 0.071,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_8015AE2C.o": 0.091,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_8015C32C.o": 0.439,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_8016AB6C.o": 0.261,
   "build/src/ov_SC03_015/ov_SC03_015_jr_80171B4C.o": 0.095,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_801734BC.o": 0.194,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_801789AC.o": 0.06,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_80178D40.o": 0.105,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_8017A4AC.o": 0.06,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_8017AE2C.o": 0.172,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_8017EB7C.o": 0.196,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_80184440.o": 0.054,
-  "build/src/ov_SC03_015/ov_SC03_015_jr_801848E4.o": 0.282,
-  "build/src/ov_SC03_015/ov_SC03_015_o0b.o": 0.062,
-  "build/src/ov_SC03_015/ov_SC03_015_o0c.o": 0.061,
-  "build/src/ov_SC03_015/ov_SC03_015_o0d.o": 0.059,
-  "build/src/ov_SC03_015/ov_SC03_015_o0e.o": 0.074,
-  "build/src/ov_SC04_011/ov_SC04_011.o": 0.121,
-  "build/src/ov_SC04_011/ov_SC04_011_after.o": 0.42,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o": 0.34,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_80135888.o": 0.055,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_80135A4C.o": 0.055,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_80135D20.o": 0.117,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_801380E0.o": 0.155,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_8013C98C.o": 0.111,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_8013F350.o": 0.08,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_8013FFD8.o": 0.07,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_80140608.o": 0.173,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_8015444C.o": 0.076,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_80154C24.o": 0.167,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_801588CC.o": 0.095,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_80159C84.o": 0.07,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_8015A3C8.o": 0.073,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_8015AE2C.o": 0.092,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.o": 0.352,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_8016AB6C.o": 0.215,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_80171B4C.o": 0.096,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_801734BC.o": 0.182,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_801789AC.o": 0.06,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_80178D40.o": 0.09,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_8017A4AC.o": 0.063,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_8017AE2C.o": 0.103,
-  "build/src/ov_SC04_011/ov_SC04_011_jr_8017D494.o": 0.424,
-  "build/src/ov_SC04_011/ov_SC04_011_o0b.o": 0.059,
-  "build/src/ov_SC04_011/ov_SC04_011_o0c.o": 0.057
+  "build/src/ov_SC03_015/ov_SC03_015_jr_801734BC.o": 0.197,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_801789AC.o": 0.051,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_80178D40.o": 0.104,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_8017A4AC.o": 0.071,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_8017AE2C.o": 0.146,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_8017EB7C.o": 0.194,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_80184440.o": 0.051,
+  "build/src/ov_SC03_015/ov_SC03_015_jr_801848E4.o": 0.284,
+  "build/src/ov_SC03_015/ov_SC03_015_o0b.o": 0.063,
+  "build/src/ov_SC03_015/ov_SC03_015_o0c.o": 0.062,
+  "build/src/ov_SC03_015/ov_SC03_015_o0d.o": 0.058,
+  "build/src/ov_SC03_015/ov_SC03_015_o0e.o": 0.068,
+  "build/src/ov_SC04_011/ov_SC04_011.o": 0.126,
+  "build/src/ov_SC04_011/ov_SC04_011_after.o": 0.411,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o": 0.327,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_80135888.o": 0.049,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_80135A4C.o": 0.053,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_80135D20.o": 0.115,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_801380E0.o": 0.142,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_8013C98C.o": 0.115,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_8013F350.o": 0.076,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_8013FFD8.o": 0.061,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_80140608.o": 0.17,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_8015444C.o": 0.066,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_80154C24.o": 0.16,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_801588CC.o": 0.081,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_80159C84.o": 0.067,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_8015A3C8.o": 0.066,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_8015AE2C.o": 0.091,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.o": 0.344,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_8016AB6C.o": 0.214,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_80171B4C.o": 0.107,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_801734BC.o": 0.162,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_801789AC.o": 0.061,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_80178D40.o": 0.08,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_8017A4AC.o": 0.066,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_8017AE2C.o": 0.1,
+  "build/src/ov_SC04_011/ov_SC04_011_jr_8017D494.o": 0.427,
+  "build/src/ov_SC04_011/ov_SC04_011_o0b.o": 0.043,
+  "build/src/ov_SC04_011/ov_SC04_011_o0c.o": 0.055
  },
  "ok": true,
- "seconds": 2.3
+ "seconds": 2.2
 }
diff --git a/.run/P36/delever/ledger.jsonl b/.run/P36/delever/ledger.jsonl
index d2a920adf4..99406f60d4 100644
--- a/.run/P36/delever/ledger.jsonl
+++ b/.run/P36/delever/ledger.jsonl
@@ -24813,3 +24813,913 @@
 {"ts": "2026-09-10 14:24:43", "label": "c2p", "rung": "E", "calib": {"head": "82da34b39", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_009/ov_SC07_009_jr_8013C98C.c", "fn": "func_8013D8FC", "addr": 2148784380, "aliases": null, "header": false, "includers": 0, "nhash_before": "cd8d6803486795564db61df0a56ff61125fd2d6e", "nhash_after": "7a348fef3b0393c49ed38bd252e1ad2efc8ce9d8", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8013C98C.c:func_8013D8FC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.067, "objects": ["build/src/ov_SC07_009/ov_SC07_009_jr_8013C98C.o"], "before_text": "void func_8013D8FC(void)\n{\n\n    extern s16 *D_801A2A24;\n    s16 *psVar3;\n    register s16 *psVar2 __asm__(\"$16\");  // !FAKE: pin $16 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 c9;\n    s32 cff;\n    u16 sVar1;\n    s16 buf[4];\n\n    psVar3 = D_801A2A24;\n    if (psVar3 != (s16 *)0x0 && (sVar1 = (u16)*psVar3, sVar1 != 0xff)) {\n        c9 = 9;\n        cff = 0xff;\n        psVar2 = psVar3 + 5;\n        do {\n            if (sVar1 == c9) {\n                s32 arg2 = *(s32 *)(psVar2 + 1) + psVar2[-1] * 2;\n                buf[0] = psVar2[-3];\n                buf[1] = psVar2[-2];\n                buf[2] = psVar2[-1];\n                buf[3] = *psVar2;\n                ((void (*)(s32, s32))func_800599B8)((s32)buf, arg2);\n            }\n            psVar3 = psVar3 + 8;\n            sVar1 = (u16)*psVar3;\n            psVar2 = psVar2 + 8;\n        } while (sVar1 != cff);\n    }\n}\n", "after_text": "void func_8013D8FC(void)\n{\n\n    extern s16 *D_801A2A24;\n    Cmd_8013D53C *p;\n    s16 buf[4];\n\n    p = (Cmd_8013D53C *)D_801A2A24;\n    if (p != 0) {\n        while (p->cmd != 0xff) {\n            if (p->cmd == 9) {\n                u16 *data = p->data + p->w;\n                buf[0] = p->pad4;\n                buf[1] = p->pad6;\n                buf[2] = p->w;\n                buf[3] = p->h;\n                ((void (*)(s16 *, u16 *))func_800599B8)(buf, data);\n            }\n            p++;\n        }\n    }\n}\n"}
 {"ts": "2026-09-10 14:24:43", "label": "c2p", "rung": "E", "calib": {"head": "82da34b39", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_011/ov_SC07_011_jr_8013C98C.c", "fn": "func_8013D8FC", "addr": 2148784380, "aliases": null, "header": false, "includers": 0, "nhash_before": "cd8d6803486795564db61df0a56ff61125fd2d6e", "nhash_after": "7a348fef3b0393c49ed38bd252e1ad2efc8ce9d8", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8013C98C.c:func_8013D8FC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.068, "objects": ["build/src/ov_SC07_011/ov_SC07_011_jr_8013C98C.o"], "before_text": "void func_8013D8FC(void)\n{\n\n    extern s16 *D_8018F14C;\n    s16 *psVar3;\n    register s16 *psVar2 __asm__(\"$16\");  // !FAKE: pin $16 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 c9;\n    s32 cff;\n    u16 sVar1;\n    s16 buf[4];\n\n    psVar3 = D_8018F14C;\n    if (psVar3 != (s16 *)0x0 && (sVar1 = (u16)*psVar3, sVar1 != 0xff)) {\n        c9 = 9;\n        cff = 0xff;\n        psVar2 = psVar3 + 5;\n        do {\n            if (sVar1 == c9) {\n                s32 arg2 = *(s32 *)(psVar2 + 1) + psVar2[-1] * 2;\n                buf[0] = psVar2[-3];\n                buf[1] = psVar2[-2];\n                buf[2] = psVar2[-1];\n                buf[3] = *psVar2;\n                ((void (*)(s32, s32))func_800599B8)((s32)buf, arg2);\n            }\n            psVar3 = psVar3 + 8;\n            sVar1 = (u16)*psVar3;\n            psVar2 = psVar2 + 8;\n        } while (sVar1 != cff);\n    }\n}\n", "after_text": "void func_8013D8FC(void)\n{\n\n    extern s16 *D_8018F14C;\n    Cmd_8013D53C *p;\n    s16 buf[4];\n\n    p = (Cmd_8013D53C *)D_8018F14C;\n    if (p != 0) {\n        while (p->cmd != 0xff) {\n            if (p->cmd == 9) {\n                u16 *data = p->data + p->w;\n                buf[0] = p->pad4;\n                buf[1] = p->pad6;\n                buf[2] = p->w;\n                buf[3] = p->h;\n                ((void (*)(s16 *, u16 *))func_800599B8)(buf, data);\n            }\n            p++;\n        }\n    }\n}\n"}
 {"ts": "2026-09-10 14:24:44", "label": "c2p", "rung": "E", "calib": {"head": "82da34b39", "stamp": "b44c5a8a3423"}, "tu": "src/shared/ov/func_8013D8FC__392f2627.h", "fn": "func_8013D8FC", "addr": 2148784380, "aliases": null, "header": true, "includers": 3, "nhash_before": "cd8d6803486795564db61df0a56ff61125fd2d6e", "nhash_after": "7a348fef3b0393c49ed38bd252e1ad2efc8ce9d8", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8013C98C.c:func_8013D8FC", "verdict": "LEVER-FREE", "sites": [], "compiles": 3, "seconds": 0.209, "objects": ["build/src/ov_SC03_126/ov_SC03_126_jr_8013C98C.o", "build/src/ov_SC04_021/ov_SC04_021_jr_8013C98C.o", "build/src/ov_SC05_019/ov_SC05_019_jr_8013C98C.o"], "before_text": "void func_8013D8FC(void)\n{\n\n    extern s16 *D_8018E774;\n    s16 *psVar3;\n    register s16 *psVar2 __asm__(\"$16\");  // !FAKE: pin $16 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n    s32 c9;\n    s32 cff;\n    u16 sVar1;\n    s16 buf[4];\n\n    psVar3 = D_8018E774;\n    if (psVar3 != (s16 *)0x0 && (sVar1 = (u16)*psVar3, sVar1 != 0xff)) {\n        c9 = 9;\n        cff = 0xff;\n        psVar2 = psVar3 + 5;\n        do {\n            if (sVar1 == c9) {\n                s32 arg2 = *(s32 *)(psVar2 + 1) + psVar2[-1] * 2;\n                buf[0] = psVar2[-3];\n                buf[1] = psVar2[-2];\n                buf[2] = psVar2[-1];\n                buf[3] = *psVar2;\n                ((void (*)(s32, s32))func_800599B8)((s32)buf, arg2);\n            }\n            psVar3 = psVar3 + 8;\n            sVar1 = (u16)*psVar3;\n            psVar2 = psVar2 + 8;\n        } while (sVar1 != cff);\n    }\n}\n", "after_text": "void func_8013D8FC(void)\n{\n\n    extern s16 *D_8018E774;\n    Cmd_8013D53C *p;\n    s16 buf[4];\n\n    p = (Cmd_8013D53C *)D_8018E774;\n    if (p != 0) {\n        while (p->cmd != 0xff) {\n            if (p->cmd == 9) {\n                u16 *data = p->data + p->w;\n                buf[0] = p->pad4;\n                buf[1] = p->pad6;\n                buf[2] = p->w;\n                buf[3] = p->h;\n                ((void (*)(s16 *, u16 *))func_800599B8)(buf, data);\n            }\n            p++;\n        }\n    }\n}\n"}
+{"ts": "2026-09-10 14:30:41", "label": "c4", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "T7 agent c4", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801909C0;\n    extern u8 D_801909BC;\n    extern u8 D_801909C8;\n    extern u16 D_801EDA40;\n    extern s16 D_801EDA3C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801909C0);\n    u16 *pB = (*(u16 * *)&D_801909BC);\n    u16 *pC = (*(u16 * *)&D_801909C8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801EDA40 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801EDA3C != 0) {\n            D_801EDA40 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801909C0;\n    extern u8 D_801909BC;\n    extern u8 D_801909C8;\n    extern u16 D_801EDA40;\n    extern s16 D_801EDA3C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801909C0);\n    u16 *pB = (*(u16 * *)&D_801909BC);\n    u16 *pC = (*(u16 * *)&D_801909C8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801EDA40 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801EDA3C != 0) {\n            D_801EDA40 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:50", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.248, "objects": ["build/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F19C;\n    extern u8 D_8017F198;\n    extern u8 D_8017F1A4;\n    extern u16 D_801A4458;\n    extern s16 D_801A4454;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F19C);\n    u16 *pB = (*(u16 * *)&D_8017F198);\n    u16 *pC = (*(u16 * *)&D_8017F1A4);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A4458 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A4454 != 0) {\n            D_801A4458 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F19C;\n    extern u8 D_8017F198;\n    extern u8 D_8017F1A4;\n    extern u16 D_801A4458;\n    extern s16 D_801A4454;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F19C);\n    u16 *pB = (*(u16 * *)&D_8017F198);\n    u16 *pC = (*(u16 * *)&D_8017F1A4);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A4458 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A4454 != 0) {\n            D_801A4458 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:50", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F7B0;\n    extern u8 D_8017F7AC;\n    extern u8 D_8017F7B8;\n    extern u16 D_8018EE50;\n    extern s16 D_8018EE4C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F7B0);\n    u16 *pB = (*(u16 * *)&D_8017F7AC);\n    u16 *pC = (*(u16 * *)&D_8017F7B8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018EE50 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018EE4C != 0) {\n            D_8018EE50 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F7B0;\n    extern u8 D_8017F7AC;\n    extern u8 D_8017F7B8;\n    extern u16 D_8018EE50;\n    extern s16 D_8018EE4C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F7B0);\n    u16 *pB = (*(u16 * *)&D_8017F7AC);\n    u16 *pC = (*(u16 * *)&D_8017F7B8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018EE50 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018EE4C != 0) {\n            D_8018EE50 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:50", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80183DEC;\n    extern u8 D_80183DE8;\n    extern u8 D_80183DF4;\n    extern u16 D_801EC6E8;\n    extern s16 D_801EC6E4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80183DEC);\n    u16 *pB = (*(u16 * *)&D_80183DE8);\n    u16 *pC = (*(u16 * *)&D_80183DF4);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801EC6E8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801EC6E4 != 0) {\n            D_801EC6E8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80183DEC;\n    extern u8 D_80183DE8;\n    extern u8 D_80183DF4;\n    extern u16 D_801EC6E8;\n    extern s16 D_801EC6E4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80183DEC);\n    u16 *pB = (*(u16 * *)&D_80183DE8);\n    u16 *pC = (*(u16 * *)&D_80183DF4);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801EC6E8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801EC6E4 != 0) {\n            D_801EC6E8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:51", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.252, "objects": ["build/src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017FD24;\n    extern u8 D_8017FD20;\n    extern u8 D_8017FD2C;\n    extern u16 D_801A2060;\n    extern s16 D_801A205C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017FD24);\n    u16 *pB = (*(u16 * *)&D_8017FD20);\n    u16 *pC = (*(u16 * *)&D_8017FD2C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A2060 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A205C != 0) {\n            D_801A2060 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017FD24;\n    extern u8 D_8017FD20;\n    extern u8 D_8017FD2C;\n    extern u16 D_801A2060;\n    extern s16 D_801A205C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017FD24);\n    u16 *pB = (*(u16 * *)&D_8017FD20);\n    u16 *pC = (*(u16 * *)&D_8017FD2C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A2060 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A205C != 0) {\n            D_801A2060 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:51", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182F0C;\n    extern u8 D_80182F08;\n    extern u8 D_80182F14;\n    extern u16 D_801F1EC0;\n    extern s16 D_801F1EBC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182F0C);\n    u16 *pB = (*(u16 * *)&D_80182F08);\n    u16 *pC = (*(u16 * *)&D_80182F14);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801F1EC0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801F1EBC != 0) {\n            D_801F1EC0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182F0C;\n    extern u8 D_80182F08;\n    extern u8 D_80182F14;\n    extern u16 D_801F1EC0;\n    extern s16 D_801F1EBC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182F0C);\n    u16 *pB = (*(u16 * *)&D_80182F08);\n    u16 *pC = (*(u16 * *)&D_80182F14);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801F1EC0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801F1EBC != 0) {\n            D_801F1EC0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:51", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017EB8C;\n    extern u8 D_8017EB88;\n    extern u8 D_8017EB94;\n    extern u16 D_8019A940;\n    extern s16 D_8019A93C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017EB8C);\n    u16 *pB = (*(u16 * *)&D_8017EB88);\n    u16 *pC = (*(u16 * *)&D_8017EB94);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019A940 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019A93C != 0) {\n            D_8019A940 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017EB8C;\n    extern u8 D_8017EB88;\n    extern u8 D_8017EB94;\n    extern u16 D_8019A940;\n    extern s16 D_8019A93C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017EB8C);\n    u16 *pB = (*(u16 * *)&D_8017EB88);\n    u16 *pC = (*(u16 * *)&D_8017EB94);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019A940 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019A93C != 0) {\n            D_8019A940 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:52", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186DE0;\n    extern u8 D_80186DDC;\n    extern u8 D_80186DE8;\n    extern u16 D_801C6218;\n    extern s16 D_801C6214;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186DE0);\n    u16 *pB = (*(u16 * *)&D_80186DDC);\n    u16 *pC = (*(u16 * *)&D_80186DE8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C6218 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C6214 != 0) {\n            D_801C6218 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186DE0;\n    extern u8 D_80186DDC;\n    extern u8 D_80186DE8;\n    extern u16 D_801C6218;\n    extern s16 D_801C6214;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186DE0);\n    u16 *pB = (*(u16 * *)&D_80186DDC);\n    u16 *pC = (*(u16 * *)&D_80186DE8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C6218 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C6214 != 0) {\n            D_801C6218 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:52", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80183AEC;\n    extern u8 D_80183AE8;\n    extern u8 D_80183AF4;\n    extern u16 D_801C4770;\n    extern s16 D_801C476C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80183AEC);\n    u16 *pB = (*(u16 * *)&D_80183AE8);\n    u16 *pC = (*(u16 * *)&D_80183AF4);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C4770 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C476C != 0) {\n            D_801C4770 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80183AEC;\n    extern u8 D_80183AE8;\n    extern u8 D_80183AF4;\n    extern u16 D_801C4770;\n    extern s16 D_801C476C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80183AEC);\n    u16 *pB = (*(u16 * *)&D_80183AE8);\n    u16 *pC = (*(u16 * *)&D_80183AF4);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C4770 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C476C != 0) {\n            D_801C4770 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:52", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E270;\n    extern u8 D_8017E26C;\n    extern u8 D_8017E278;\n    extern u16 D_80194F98;\n    extern s16 D_80194F94;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E270);\n    u16 *pB = (*(u16 * *)&D_8017E26C);\n    u16 *pC = (*(u16 * *)&D_8017E278);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80194F98 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80194F94 != 0) {\n            D_80194F98 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E270;\n    extern u8 D_8017E26C;\n    extern u8 D_8017E278;\n    extern u16 D_80194F98;\n    extern s16 D_80194F94;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E270);\n    u16 *pB = (*(u16 * *)&D_8017E26C);\n    u16 *pC = (*(u16 * *)&D_8017E278);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80194F98 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80194F94 != 0) {\n            D_80194F98 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:53", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80190E74;\n    extern u8 D_80190E70;\n    extern u8 D_80190E7C;\n    extern u16 D_801E3010;\n    extern s16 D_801E300C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80190E74);\n    u16 *pB = (*(u16 * *)&D_80190E70);\n    u16 *pC = (*(u16 * *)&D_80190E7C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E3010 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E300C != 0) {\n            D_801E3010 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80190E74;\n    extern u8 D_80190E70;\n    extern u8 D_80190E7C;\n    extern u16 D_801E3010;\n    extern s16 D_801E300C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80190E74);\n    u16 *pB = (*(u16 * *)&D_80190E70);\n    u16 *pC = (*(u16 * *)&D_80190E7C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E3010 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E300C != 0) {\n            D_801E3010 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:53", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E7D8;\n    extern u8 D_8017E7D4;\n    extern u8 D_8017E7E0;\n    extern u16 D_8018F070;\n    extern s16 D_8018F06C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E7D8);\n    u16 *pB = (*(u16 * *)&D_8017E7D4);\n    u16 *pC = (*(u16 * *)&D_8017E7E0);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018F070 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018F06C != 0) {\n            D_8018F070 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E7D8;\n    extern u8 D_8017E7D4;\n    extern u8 D_8017E7E0;\n    extern u16 D_8018F070;\n    extern s16 D_8018F06C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E7D8);\n    u16 *pB = (*(u16 * *)&D_8017E7D4);\n    u16 *pC = (*(u16 * *)&D_8017E7E0);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018F070 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018F06C != 0) {\n            D_8018F070 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:53", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018AA68;\n    extern u8 D_8018AA64;\n    extern u8 D_8018AA70;\n    extern u16 D_801EE4B0;\n    extern s16 D_801EE4AC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018AA68);\n    u16 *pB = (*(u16 * *)&D_8018AA64);\n    u16 *pC = (*(u16 * *)&D_8018AA70);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801EE4B0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801EE4AC != 0) {\n            D_801EE4B0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018AA68;\n    extern u8 D_8018AA64;\n    extern u8 D_8018AA70;\n    extern u16 D_801EE4B0;\n    extern s16 D_801EE4AC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018AA68);\n    u16 *pB = (*(u16 * *)&D_8018AA64);\n    u16 *pC = (*(u16 * *)&D_8018AA70);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801EE4B0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801EE4AC != 0) {\n            D_801EE4B0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:54", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801912C4;\n    extern u8 D_801912C0;\n    extern u8 D_801912CC;\n    extern u16 D_801E9EF0;\n    extern s16 D_801E9EEC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801912C4);\n    u16 *pB = (*(u16 * *)&D_801912C0);\n    u16 *pC = (*(u16 * *)&D_801912CC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E9EF0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E9EEC != 0) {\n            D_801E9EF0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801912C4;\n    extern u8 D_801912C0;\n    extern u8 D_801912CC;\n    extern u16 D_801E9EF0;\n    extern s16 D_801E9EEC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801912C4);\n    u16 *pB = (*(u16 * *)&D_801912C0);\n    u16 *pC = (*(u16 * *)&D_801912CC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E9EF0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E9EEC != 0) {\n            D_801E9EF0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:54", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184A10;\n    extern u8 D_80184A0C;\n    extern u8 D_80184A18;\n    extern u16 D_801B2C88;\n    extern s16 D_801B2C84;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184A10);\n    u16 *pB = (*(u16 * *)&D_80184A0C);\n    u16 *pC = (*(u16 * *)&D_80184A18);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B2C88 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B2C84 != 0) {\n            D_801B2C88 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184A10;\n    extern u8 D_80184A0C;\n    extern u8 D_80184A18;\n    extern u16 D_801B2C88;\n    extern s16 D_801B2C84;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184A10);\n    u16 *pB = (*(u16 * *)&D_80184A0C);\n    u16 *pC = (*(u16 * *)&D_80184A18);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B2C88 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B2C84 != 0) {\n            D_801B2C88 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:54", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.483, "objects": ["build/src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.o", "build/src/ov_SC01_006/ov_SC01_006_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182944;\n    extern u8 D_80182940;\n    extern u8 D_8018294C;\n    extern u16 D_801CC5B0;\n    extern s16 D_801CC5AC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182944);\n    u16 *pB = (*(u16 * *)&D_80182940);\n    u16 *pC = (*(u16 * *)&D_8018294C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CC5B0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CC5AC != 0) {\n            D_801CC5B0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182944;\n    extern u8 D_80182940;\n    extern u8 D_8018294C;\n    extern u16 D_801CC5B0;\n    extern s16 D_801CC5AC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182944);\n    u16 *pB = (*(u16 * *)&D_80182940);\n    u16 *pC = (*(u16 * *)&D_8018294C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CC5B0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CC5AC != 0) {\n            D_801CC5B0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:55", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018005C;\n    extern u8 D_80180058;\n    extern u8 D_80180064;\n    extern u16 D_80191A20;\n    extern s16 D_80191A1C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018005C);\n    u16 *pB = (*(u16 * *)&D_80180058);\n    u16 *pC = (*(u16 * *)&D_80180064);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80191A20 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80191A1C != 0) {\n            D_80191A20 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018005C;\n    extern u8 D_80180058;\n    extern u8 D_80180064;\n    extern u16 D_80191A20;\n    extern s16 D_80191A1C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018005C);\n    u16 *pB = (*(u16 * *)&D_80180058);\n    u16 *pC = (*(u16 * *)&D_80180064);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80191A20 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80191A1C != 0) {\n            D_80191A20 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:55", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801866B0;\n    extern u8 D_801866AC;\n    extern u8 D_801866B8;\n    extern u16 D_801CEE60;\n    extern s16 D_801CEE5C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801866B0);\n    u16 *pB = (*(u16 * *)&D_801866AC);\n    u16 *pC = (*(u16 * *)&D_801866B8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CEE60 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CEE5C != 0) {\n            D_801CEE60 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801866B0;\n    extern u8 D_801866AC;\n    extern u8 D_801866B8;\n    extern u16 D_801CEE60;\n    extern s16 D_801CEE5C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801866B0);\n    u16 *pB = (*(u16 * *)&D_801866AC);\n    u16 *pC = (*(u16 * *)&D_801866B8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CEE60 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CEE5C != 0) {\n            D_801CEE60 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:56", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.488, "objects": ["build/src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.o", "build/src/ov_SC02_003/ov_SC02_003_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018B190;\n    extern u8 D_8018B18C;\n    extern u8 D_8018B198;\n    extern u16 D_801E6D48;\n    extern s16 D_801E6D44;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018B190);\n    u16 *pB = (*(u16 * *)&D_8018B18C);\n    u16 *pC = (*(u16 * *)&D_8018B198);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E6D48 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E6D44 != 0) {\n            D_801E6D48 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018B190;\n    extern u8 D_8018B18C;\n    extern u8 D_8018B198;\n    extern u16 D_801E6D48;\n    extern s16 D_801E6D44;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018B190);\n    u16 *pB = (*(u16 * *)&D_8018B18C);\n    u16 *pC = (*(u16 * *)&D_8018B198);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E6D48 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E6D44 != 0) {\n            D_801E6D48 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:56", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018B7D4;\n    extern u8 D_8018B7D0;\n    extern u8 D_8018B7DC;\n    extern u16 D_801D8BD0;\n    extern s16 D_801D8BCC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018B7D4);\n    u16 *pB = (*(u16 * *)&D_8018B7D0);\n    u16 *pC = (*(u16 * *)&D_8018B7DC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D8BD0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D8BCC != 0) {\n            D_801D8BD0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018B7D4;\n    extern u8 D_8018B7D0;\n    extern u8 D_8018B7DC;\n    extern u16 D_801D8BD0;\n    extern s16 D_801D8BCC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018B7D4);\n    u16 *pB = (*(u16 * *)&D_8018B7D0);\n    u16 *pC = (*(u16 * *)&D_8018B7DC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D8BD0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D8BCC != 0) {\n            D_801D8BD0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:56", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185204;\n    extern u8 D_80185200;\n    extern u8 D_8018520C;\n    extern u16 D_801B62E8;\n    extern s16 D_801B62E4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185204);\n    u16 *pB = (*(u16 * *)&D_80185200);\n    u16 *pC = (*(u16 * *)&D_8018520C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B62E8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B62E4 != 0) {\n            D_801B62E8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185204;\n    extern u8 D_80185200;\n    extern u8 D_8018520C;\n    extern u16 D_801B62E8;\n    extern s16 D_801B62E4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185204);\n    u16 *pB = (*(u16 * *)&D_80185200);\n    u16 *pC = (*(u16 * *)&D_8018520C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B62E8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B62E4 != 0) {\n            D_801B62E8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:57", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018B9D8;\n    extern u8 D_8018B9D4;\n    extern u8 D_8018B9E0;\n    extern u16 D_801D1B70;\n    extern s16 D_801D1B6C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018B9D8);\n    u16 *pB = (*(u16 * *)&D_8018B9D4);\n    u16 *pC = (*(u16 * *)&D_8018B9E0);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D1B70 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D1B6C != 0) {\n            D_801D1B70 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018B9D8;\n    extern u8 D_8018B9D4;\n    extern u8 D_8018B9E0;\n    extern u16 D_801D1B70;\n    extern s16 D_801D1B6C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018B9D8);\n    u16 *pB = (*(u16 * *)&D_8018B9D4);\n    u16 *pC = (*(u16 * *)&D_8018B9E0);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D1B70 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D1B6C != 0) {\n            D_801D1B70 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:57", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184A64;\n    extern u8 D_80184A60;\n    extern u8 D_80184A6C;\n    extern u16 D_801BD618;\n    extern s16 D_801BD614;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184A64);\n    u16 *pB = (*(u16 * *)&D_80184A60);\n    u16 *pC = (*(u16 * *)&D_80184A6C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801BD618 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801BD614 != 0) {\n            D_801BD618 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184A64;\n    extern u8 D_80184A60;\n    extern u8 D_80184A6C;\n    extern u16 D_801BD618;\n    extern s16 D_801BD614;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184A64);\n    u16 *pB = (*(u16 * *)&D_80184A60);\n    u16 *pC = (*(u16 * *)&D_80184A6C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801BD618 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801BD614 != 0) {\n            D_801BD618 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:57", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F690;\n    extern u8 D_8017F68C;\n    extern u8 D_8017F698;\n    extern u16 D_8019F9C8;\n    extern s16 D_8019F9C4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F690);\n    u16 *pB = (*(u16 * *)&D_8017F68C);\n    u16 *pC = (*(u16 * *)&D_8017F698);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019F9C8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019F9C4 != 0) {\n            D_8019F9C8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F690;\n    extern u8 D_8017F68C;\n    extern u8 D_8017F698;\n    extern u16 D_8019F9C8;\n    extern s16 D_8019F9C4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F690);\n    u16 *pB = (*(u16 * *)&D_8017F68C);\n    u16 *pC = (*(u16 * *)&D_8017F698);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019F9C8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019F9C4 != 0) {\n            D_8019F9C8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:58", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018DAA0;\n    extern u8 D_8018DA9C;\n    extern u8 D_8018DAA8;\n    extern u16 D_801ED3C0;\n    extern s16 D_801ED3BC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018DAA0);\n    u16 *pB = (*(u16 * *)&D_8018DA9C);\n    u16 *pC = (*(u16 * *)&D_8018DAA8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801ED3C0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801ED3BC != 0) {\n            D_801ED3C0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018DAA0;\n    extern u8 D_8018DA9C;\n    extern u8 D_8018DAA8;\n    extern u16 D_801ED3C0;\n    extern s16 D_801ED3BC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018DAA0);\n    u16 *pB = (*(u16 * *)&D_8018DA9C);\n    u16 *pC = (*(u16 * *)&D_8018DAA8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801ED3C0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801ED3BC != 0) {\n            D_801ED3C0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:58", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185360;\n    extern u8 D_8018535C;\n    extern u8 D_80185368;\n    extern u16 D_801B7D40;\n    extern s16 D_801B7D3C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185360);\n    u16 *pB = (*(u16 * *)&D_8018535C);\n    u16 *pC = (*(u16 * *)&D_80185368);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B7D40 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B7D3C != 0) {\n            D_801B7D40 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185360;\n    extern u8 D_8018535C;\n    extern u8 D_80185368;\n    extern u16 D_801B7D40;\n    extern s16 D_801B7D3C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185360);\n    u16 *pB = (*(u16 * *)&D_8018535C);\n    u16 *pC = (*(u16 * *)&D_80185368);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B7D40 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B7D3C != 0) {\n            D_801B7D40 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:58", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185A90;\n    extern u8 D_80185A8C;\n    extern u8 D_80185A98;\n    extern u16 D_801CA440;\n    extern s16 D_801CA43C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185A90);\n    u16 *pB = (*(u16 * *)&D_80185A8C);\n    u16 *pC = (*(u16 * *)&D_80185A98);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CA440 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CA43C != 0) {\n            D_801CA440 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185A90;\n    extern u8 D_80185A8C;\n    extern u8 D_80185A98;\n    extern u16 D_801CA440;\n    extern s16 D_801CA43C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185A90);\n    u16 *pB = (*(u16 * *)&D_80185A8C);\n    u16 *pC = (*(u16 * *)&D_80185A98);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CA440 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CA43C != 0) {\n            D_801CA440 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:59", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F858;\n    extern u8 D_8017F854;\n    extern u8 D_8017F860;\n    extern u16 D_8018E748;\n    extern s16 D_8018E744;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F858);\n    u16 *pB = (*(u16 * *)&D_8017F854);\n    u16 *pC = (*(u16 * *)&D_8017F860);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018E748 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018E744 != 0) {\n            D_8018E748 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F858;\n    extern u8 D_8017F854;\n    extern u8 D_8017F860;\n    extern u16 D_8018E748;\n    extern s16 D_8018E744;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F858);\n    u16 *pB = (*(u16 * *)&D_8017F854);\n    u16 *pC = (*(u16 * *)&D_8017F860);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018E748 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018E744 != 0) {\n            D_8018E748 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:59", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018CB74;\n    extern u8 D_8018CB70;\n    extern u8 D_8018CB7C;\n    extern u16 D_801F60C0;\n    extern s16 D_801F60BC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018CB74);\n    u16 *pB = (*(u16 * *)&D_8018CB70);\n    u16 *pC = (*(u16 * *)&D_8018CB7C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801F60C0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801F60BC != 0) {\n            D_801F60C0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018CB74;\n    extern u8 D_8018CB70;\n    extern u8 D_8018CB7C;\n    extern u16 D_801F60C0;\n    extern s16 D_801F60BC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018CB74);\n    u16 *pB = (*(u16 * *)&D_8018CB70);\n    u16 *pC = (*(u16 * *)&D_8018CB7C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801F60C0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801F60BC != 0) {\n            D_801F60C0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:30:59", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E6DC;\n    extern u8 D_8017E6D8;\n    extern u8 D_8017E6E4;\n    extern u16 D_80193D30;\n    extern s16 D_80193D2C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E6DC);\n    u16 *pB = (*(u16 * *)&D_8017E6D8);\n    u16 *pC = (*(u16 * *)&D_8017E6E4);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80193D30 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80193D2C != 0) {\n            D_80193D30 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E6DC;\n    extern u8 D_8017E6D8;\n    extern u8 D_8017E6E4;\n    extern u16 D_80193D30;\n    extern s16 D_80193D2C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E6DC);\n    u16 *pB = (*(u16 * *)&D_8017E6D8);\n    u16 *pC = (*(u16 * *)&D_8017E6E4);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80193D30 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80193D2C != 0) {\n            D_80193D30 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:00", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.256, "objects": ["build/src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018048C;\n    extern u8 D_80180488;\n    extern u8 D_80180494;\n    extern u16 D_8019EC78;\n    extern s16 D_8019EC74;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018048C);\n    u16 *pB = (*(u16 * *)&D_80180488);\n    u16 *pC = (*(u16 * *)&D_80180494);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019EC78 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019EC74 != 0) {\n            D_8019EC78 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018048C;\n    extern u8 D_80180488;\n    extern u8 D_80180494;\n    extern u16 D_8019EC78;\n    extern s16 D_8019EC74;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018048C);\n    u16 *pB = (*(u16 * *)&D_80180488);\n    u16 *pC = (*(u16 * *)&D_80180494);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019EC78 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019EC74 != 0) {\n            D_8019EC78 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:00", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018796C;\n    extern u8 D_80187968;\n    extern u8 D_80187974;\n    extern u16 D_801E8A18;\n    extern s16 D_801E8A14;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018796C);\n    u16 *pB = (*(u16 * *)&D_80187968);\n    u16 *pC = (*(u16 * *)&D_80187974);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E8A18 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E8A14 != 0) {\n            D_801E8A18 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018796C;\n    extern u8 D_80187968;\n    extern u8 D_80187974;\n    extern u16 D_801E8A18;\n    extern s16 D_801E8A14;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018796C);\n    u16 *pB = (*(u16 * *)&D_80187968);\n    u16 *pC = (*(u16 * *)&D_80187974);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E8A18 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E8A14 != 0) {\n            D_801E8A18 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:00", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801814C4;\n    extern u8 D_801814C0;\n    extern u8 D_801814CC;\n    extern u16 D_801AC000;\n    extern s16 D_801ABFFC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801814C4);\n    u16 *pB = (*(u16 * *)&D_801814C0);\n    u16 *pC = (*(u16 * *)&D_801814CC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801AC000 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801ABFFC != 0) {\n            D_801AC000 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801814C4;\n    extern u8 D_801814C0;\n    extern u8 D_801814CC;\n    extern u16 D_801AC000;\n    extern s16 D_801ABFFC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801814C4);\n    u16 *pB = (*(u16 * *)&D_801814C0);\n    u16 *pC = (*(u16 * *)&D_801814CC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801AC000 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801ABFFC != 0) {\n            D_801AC000 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:01", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801817FC;\n    extern u8 D_801817F8;\n    extern u8 D_80181804;\n    extern u16 D_801A0F10;\n    extern s16 D_801A0F0C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801817FC);\n    u16 *pB = (*(u16 * *)&D_801817F8);\n    u16 *pC = (*(u16 * *)&D_80181804);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A0F10 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A0F0C != 0) {\n            D_801A0F10 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801817FC;\n    extern u8 D_801817F8;\n    extern u8 D_80181804;\n    extern u16 D_801A0F10;\n    extern s16 D_801A0F0C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801817FC);\n    u16 *pB = (*(u16 * *)&D_801817F8);\n    u16 *pC = (*(u16 * *)&D_80181804);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A0F10 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A0F0C != 0) {\n            D_801A0F10 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:01", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_037/ov_SC02_037_jr_80131340.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.119, "objects": ["build/src/ov_SC02_037/ov_SC02_037_jr_80131340.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801841A0;\n    extern u8 D_8018419C;\n    extern u8 D_801841A8;\n    extern u16 D_801C8428;\n    extern s16 D_801C8424;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801841A0);\n    u16 *pB = (*(u16 * *)&D_8018419C);\n    u16 *pC = (*(u16 * *)&D_801841A8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C8428 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C8424 != 0) {\n            D_801C8428 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801841A0;\n    extern u8 D_8018419C;\n    extern u8 D_801841A8;\n    extern u16 D_801C8428;\n    extern s16 D_801C8424;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801841A0);\n    u16 *pB = (*(u16 * *)&D_8018419C);\n    u16 *pC = (*(u16 * *)&D_801841A8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C8428 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C8424 != 0) {\n            D_801C8428 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:01", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_MAIN_012/ov_MAIN_012_jr_80131340.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.123, "objects": ["build/src/ov_MAIN_012/ov_MAIN_012_jr_80131340.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E914;\n    extern u8 D_8017E910;\n    extern u8 D_8017E91C;\n    extern u16 D_80184130;\n    extern s16 D_8018412C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E914);\n    u16 *pB = (*(u16 * *)&D_8017E910);\n    u16 *pC = (*(u16 * *)&D_8017E91C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80184130 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018412C != 0) {\n            D_80184130 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E914;\n    extern u8 D_8017E910;\n    extern u8 D_8017E91C;\n    extern u16 D_80184130;\n    extern s16 D_8018412C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E914);\n    u16 *pB = (*(u16 * *)&D_8017E910);\n    u16 *pC = (*(u16 * *)&D_8017E91C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80184130 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018412C != 0) {\n            D_80184130 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:01", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_077/ov_SC01_077_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.253, "objects": ["build/src/ov_SC01_077/ov_SC01_077_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801870B0;\n    extern u8 D_801870AC;\n    extern u8 D_801870B8;\n    extern u16 D_801D9500;\n    extern s16 D_801D94FC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801870B0);\n    u16 *pB = (*(u16 * *)&D_801870AC);\n    u16 *pC = (*(u16 * *)&D_801870B8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D9500 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D94FC != 0) {\n            D_801D9500 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801870B0;\n    extern u8 D_801870AC;\n    extern u8 D_801870B8;\n    extern u16 D_801D9500;\n    extern s16 D_801D94FC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801870B0);\n    u16 *pB = (*(u16 * *)&D_801870AC);\n    u16 *pC = (*(u16 * *)&D_801870B8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D9500 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D94FC != 0) {\n            D_801D9500 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:02", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F47C;\n    extern u8 D_8017F478;\n    extern u8 D_8017F484;\n    extern u16 D_80197958;\n    extern s16 D_80197954;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F47C);\n    u16 *pB = (*(u16 * *)&D_8017F478);\n    u16 *pC = (*(u16 * *)&D_8017F484);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80197958 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80197954 != 0) {\n            D_80197958 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F47C;\n    extern u8 D_8017F478;\n    extern u8 D_8017F484;\n    extern u16 D_80197958;\n    extern s16 D_80197954;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F47C);\n    u16 *pB = (*(u16 * *)&D_8017F478);\n    u16 *pC = (*(u16 * *)&D_8017F484);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80197958 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80197954 != 0) {\n            D_80197958 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:02", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.248, "objects": ["build/src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018BF6C;\n    extern u8 D_8018BF68;\n    extern u8 D_8018BF74;\n    extern u16 D_801EA228;\n    extern s16 D_801EA224;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018BF6C);\n    u16 *pB = (*(u16 * *)&D_8018BF68);\n    u16 *pC = (*(u16 * *)&D_8018BF74);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801EA228 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801EA224 != 0) {\n            D_801EA228 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018BF6C;\n    extern u8 D_8018BF68;\n    extern u8 D_8018BF74;\n    extern u16 D_801EA228;\n    extern s16 D_801EA224;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018BF6C);\n    u16 *pB = (*(u16 * *)&D_8018BF68);\n    u16 *pC = (*(u16 * *)&D_8018BF74);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801EA228 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801EA224 != 0) {\n            D_801EA228 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:02", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801874A0;\n    extern u8 D_8018749C;\n    extern u8 D_801874A8;\n    extern u16 D_801BFEF0;\n    extern s16 D_801BFEEC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801874A0);\n    u16 *pB = (*(u16 * *)&D_8018749C);\n    u16 *pC = (*(u16 * *)&D_801874A8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801BFEF0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801BFEEC != 0) {\n            D_801BFEF0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801874A0;\n    extern u8 D_8018749C;\n    extern u8 D_801874A8;\n    extern u16 D_801BFEF0;\n    extern s16 D_801BFEEC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801874A0);\n    u16 *pB = (*(u16 * *)&D_8018749C);\n    u16 *pC = (*(u16 * *)&D_801874A8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801BFEF0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801BFEEC != 0) {\n            D_801BFEF0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:03", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80187DA4;\n    extern u8 D_80187DA0;\n    extern u8 D_80187DAC;\n    extern u16 D_801D8200;\n    extern s16 D_801D81FC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80187DA4);\n    u16 *pB = (*(u16 * *)&D_80187DA0);\n    u16 *pC = (*(u16 * *)&D_80187DAC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D8200 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D81FC != 0) {\n            D_801D8200 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80187DA4;\n    extern u8 D_80187DA0;\n    extern u8 D_80187DAC;\n    extern u16 D_801D8200;\n    extern s16 D_801D81FC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80187DA4);\n    u16 *pB = (*(u16 * *)&D_80187DA0);\n    u16 *pC = (*(u16 * *)&D_80187DAC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D8200 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D81FC != 0) {\n            D_801D8200 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:03", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.489, "objects": ["build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o", "build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018BB00;\n    extern u8 D_8018BAFC;\n    extern u8 D_8018BB08;\n    extern u16 D_801E9580;\n    extern s16 D_801E957C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018BB00);\n    u16 *pB = (*(u16 * *)&D_8018BAFC);\n    u16 *pC = (*(u16 * *)&D_8018BB08);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E9580 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E957C != 0) {\n            D_801E9580 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018BB00;\n    extern u8 D_8018BAFC;\n    extern u8 D_8018BB08;\n    extern u16 D_801E9580;\n    extern s16 D_801E957C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018BB00);\n    u16 *pB = (*(u16 * *)&D_8018BAFC);\n    u16 *pC = (*(u16 * *)&D_8018BB08);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E9580 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E957C != 0) {\n            D_801E9580 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:04", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80193B68;\n    extern u8 D_80193B64;\n    extern u8 D_80193B70;\n    extern u16 D_801D3C58;\n    extern s16 D_801D3C54;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80193B68);\n    u16 *pB = (*(u16 * *)&D_80193B64);\n    u16 *pC = (*(u16 * *)&D_80193B70);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D3C58 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D3C54 != 0) {\n            D_801D3C58 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80193B68;\n    extern u8 D_80193B64;\n    extern u8 D_80193B70;\n    extern u16 D_801D3C58;\n    extern s16 D_801D3C54;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80193B68);\n    u16 *pB = (*(u16 * *)&D_80193B64);\n    u16 *pC = (*(u16 * *)&D_80193B70);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D3C58 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D3C54 != 0) {\n            D_801D3C58 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:04", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E2AC;\n    extern u8 D_8017E2A8;\n    extern u8 D_8017E2B4;\n    extern u16 D_8019BDA8;\n    extern s16 D_8019BDA4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E2AC);\n    u16 *pB = (*(u16 * *)&D_8017E2A8);\n    u16 *pC = (*(u16 * *)&D_8017E2B4);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019BDA8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019BDA4 != 0) {\n            D_8019BDA8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E2AC;\n    extern u8 D_8017E2A8;\n    extern u8 D_8017E2B4;\n    extern u16 D_8019BDA8;\n    extern s16 D_8019BDA4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E2AC);\n    u16 *pB = (*(u16 * *)&D_8017E2A8);\n    u16 *pC = (*(u16 * *)&D_8017E2B4);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019BDA8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019BDA4 != 0) {\n            D_8019BDA8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:04", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182340;\n    extern u8 D_8018233C;\n    extern u8 D_80182348;\n    extern u16 D_801F6DB0;\n    extern s16 D_801F6DAC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182340);\n    u16 *pB = (*(u16 * *)&D_8018233C);\n    u16 *pC = (*(u16 * *)&D_80182348);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801F6DB0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801F6DAC != 0) {\n            D_801F6DB0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182340;\n    extern u8 D_8018233C;\n    extern u8 D_80182348;\n    extern u16 D_801F6DB0;\n    extern s16 D_801F6DAC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182340);\n    u16 *pB = (*(u16 * *)&D_8018233C);\n    u16 *pC = (*(u16 * *)&D_80182348);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801F6DB0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801F6DAC != 0) {\n            D_801F6DB0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:05", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018D76C;\n    extern u8 D_8018D768;\n    extern u8 D_8018D774;\n    extern u16 D_801EB8E8;\n    extern s16 D_801EB8E4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018D76C);\n    u16 *pB = (*(u16 * *)&D_8018D768);\n    u16 *pC = (*(u16 * *)&D_8018D774);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801EB8E8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801EB8E4 != 0) {\n            D_801EB8E8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018D76C;\n    extern u8 D_8018D768;\n    extern u8 D_8018D774;\n    extern u16 D_801EB8E8;\n    extern s16 D_801EB8E4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018D76C);\n    u16 *pB = (*(u16 * *)&D_8018D768);\n    u16 *pC = (*(u16 * *)&D_8018D774);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801EB8E8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801EB8E4 != 0) {\n            D_801EB8E8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:05", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186EC8;\n    extern u8 D_80186EC4;\n    extern u8 D_80186ED0;\n    extern u16 D_801E5028;\n    extern s16 D_801E5024;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186EC8);\n    u16 *pB = (*(u16 * *)&D_80186EC4);\n    u16 *pC = (*(u16 * *)&D_80186ED0);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E5028 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E5024 != 0) {\n            D_801E5028 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186EC8;\n    extern u8 D_80186EC4;\n    extern u8 D_80186ED0;\n    extern u16 D_801E5028;\n    extern s16 D_801E5024;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186EC8);\n    u16 *pB = (*(u16 * *)&D_80186EC4);\n    u16 *pC = (*(u16 * *)&D_80186ED0);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E5028 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E5024 != 0) {\n            D_801E5028 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:05", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185DA8;\n    extern u8 D_80185DA4;\n    extern u8 D_80185DB0;\n    extern u16 D_801A8D30;\n    extern s16 D_801A8D2C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185DA8);\n    u16 *pB = (*(u16 * *)&D_80185DA4);\n    u16 *pC = (*(u16 * *)&D_80185DB0);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A8D30 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A8D2C != 0) {\n            D_801A8D30 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185DA8;\n    extern u8 D_80185DA4;\n    extern u8 D_80185DB0;\n    extern u16 D_801A8D30;\n    extern s16 D_801A8D2C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185DA8);\n    u16 *pB = (*(u16 * *)&D_80185DA4);\n    u16 *pC = (*(u16 * *)&D_80185DB0);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A8D30 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A8D2C != 0) {\n            D_801A8D30 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:06", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F160;\n    extern u8 D_8017F15C;\n    extern u8 D_8017F168;\n    extern u16 D_801997D0;\n    extern s16 D_801997CC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F160);\n    u16 *pB = (*(u16 * *)&D_8017F15C);\n    u16 *pC = (*(u16 * *)&D_8017F168);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801997D0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801997CC != 0) {\n            D_801997D0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F160;\n    extern u8 D_8017F15C;\n    extern u8 D_8017F168;\n    extern u16 D_801997D0;\n    extern s16 D_801997CC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F160);\n    u16 *pB = (*(u16 * *)&D_8017F15C);\n    u16 *pC = (*(u16 * *)&D_8017F168);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801997D0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801997CC != 0) {\n            D_801997D0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:06", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801809E4;\n    extern u8 D_801809E0;\n    extern u8 D_801809EC;\n    extern u16 D_801AA918;\n    extern s16 D_801AA914;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801809E4);\n    u16 *pB = (*(u16 * *)&D_801809E0);\n    u16 *pC = (*(u16 * *)&D_801809EC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801AA918 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801AA914 != 0) {\n            D_801AA918 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801809E4;\n    extern u8 D_801809E0;\n    extern u8 D_801809EC;\n    extern u16 D_801AA918;\n    extern s16 D_801AA914;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801809E4);\n    u16 *pB = (*(u16 * *)&D_801809E0);\n    u16 *pC = (*(u16 * *)&D_801809EC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801AA918 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801AA914 != 0) {\n            D_801AA918 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:06", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018881C;\n    extern u8 D_80188818;\n    extern u8 D_80188824;\n    extern u16 D_801AD368;\n    extern s16 D_801AD364;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018881C);\n    u16 *pB = (*(u16 * *)&D_80188818);\n    u16 *pC = (*(u16 * *)&D_80188824);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801AD368 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801AD364 != 0) {\n            D_801AD368 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018881C;\n    extern u8 D_80188818;\n    extern u8 D_80188824;\n    extern u16 D_801AD368;\n    extern s16 D_801AD364;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018881C);\n    u16 *pB = (*(u16 * *)&D_80188818);\n    u16 *pC = (*(u16 * *)&D_80188824);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801AD368 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801AD364 != 0) {\n            D_801AD368 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:07", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186F84;\n    extern u8 D_80186F80;\n    extern u8 D_80186F8C;\n    extern u16 D_801B0D68;\n    extern s16 D_801B0D64;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186F84);\n    u16 *pB = (*(u16 * *)&D_80186F80);\n    u16 *pC = (*(u16 * *)&D_80186F8C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B0D68 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B0D64 != 0) {\n            D_801B0D68 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186F84;\n    extern u8 D_80186F80;\n    extern u8 D_80186F8C;\n    extern u16 D_801B0D68;\n    extern s16 D_801B0D64;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186F84);\n    u16 *pB = (*(u16 * *)&D_80186F80);\n    u16 *pC = (*(u16 * *)&D_80186F8C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B0D68 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B0D64 != 0) {\n            D_801B0D68 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:07", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.248, "objects": ["build/src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801804C4;\n    extern u8 D_801804C0;\n    extern u8 D_801804CC;\n    extern u16 D_801A01C0;\n    extern s16 D_801A01BC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801804C4);\n    u16 *pB = (*(u16 * *)&D_801804C0);\n    u16 *pC = (*(u16 * *)&D_801804CC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A01C0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A01BC != 0) {\n            D_801A01C0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801804C4;\n    extern u8 D_801804C0;\n    extern u8 D_801804CC;\n    extern u16 D_801A01C0;\n    extern s16 D_801A01BC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801804C4);\n    u16 *pB = (*(u16 * *)&D_801804C0);\n    u16 *pC = (*(u16 * *)&D_801804CC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A01C0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A01BC != 0) {\n            D_801A01C0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:07", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F01C;\n    extern u8 D_8017F018;\n    extern u8 D_8017F024;\n    extern u16 D_801935A0;\n    extern s16 D_8019359C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F01C);\n    u16 *pB = (*(u16 * *)&D_8017F018);\n    u16 *pC = (*(u16 * *)&D_8017F024);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801935A0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019359C != 0) {\n            D_801935A0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F01C;\n    extern u8 D_8017F018;\n    extern u8 D_8017F024;\n    extern u16 D_801935A0;\n    extern s16 D_8019359C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F01C);\n    u16 *pB = (*(u16 * *)&D_8017F018);\n    u16 *pC = (*(u16 * *)&D_8017F024);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801935A0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019359C != 0) {\n            D_801935A0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:08", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018542C;\n    extern u8 D_80185428;\n    extern u8 D_80185434;\n    extern u16 D_8019E370;\n    extern s16 D_8019E36C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018542C);\n    u16 *pB = (*(u16 * *)&D_80185428);\n    u16 *pC = (*(u16 * *)&D_80185434);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019E370 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019E36C != 0) {\n            D_8019E370 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018542C;\n    extern u8 D_80185428;\n    extern u8 D_80185434;\n    extern u16 D_8019E370;\n    extern s16 D_8019E36C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018542C);\n    u16 *pB = (*(u16 * *)&D_80185428);\n    u16 *pC = (*(u16 * *)&D_80185434);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019E370 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019E36C != 0) {\n            D_8019E370 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:08", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018D8AC;\n    extern u8 D_8018D8A8;\n    extern u8 D_8018D8B4;\n    extern u16 D_801E0CD8;\n    extern s16 D_801E0CD4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018D8AC);\n    u16 *pB = (*(u16 * *)&D_8018D8A8);\n    u16 *pC = (*(u16 * *)&D_8018D8B4);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E0CD8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E0CD4 != 0) {\n            D_801E0CD8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018D8AC;\n    extern u8 D_8018D8A8;\n    extern u8 D_8018D8B4;\n    extern u16 D_801E0CD8;\n    extern s16 D_801E0CD4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018D8AC);\n    u16 *pB = (*(u16 * *)&D_8018D8A8);\n    u16 *pC = (*(u16 * *)&D_8018D8B4);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E0CD8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E0CD4 != 0) {\n            D_801E0CD8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:08", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801855F0;\n    extern u8 D_801855EC;\n    extern u8 D_801855F8;\n    extern u16 D_801B9470;\n    extern s16 D_801B946C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801855F0);\n    u16 *pB = (*(u16 * *)&D_801855EC);\n    u16 *pC = (*(u16 * *)&D_801855F8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B9470 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B946C != 0) {\n            D_801B9470 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801855F0;\n    extern u8 D_801855EC;\n    extern u8 D_801855F8;\n    extern u16 D_801B9470;\n    extern s16 D_801B946C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801855F0);\n    u16 *pB = (*(u16 * *)&D_801855EC);\n    u16 *pC = (*(u16 * *)&D_801855F8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B9470 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B946C != 0) {\n            D_801B9470 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:09", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.264, "objects": ["build/src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80189BF8;\n    extern u8 D_80189BF4;\n    extern u8 D_80189C00;\n    extern u16 D_801C54B0;\n    extern s16 D_801C54AC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80189BF8);\n    u16 *pB = (*(u16 * *)&D_80189BF4);\n    u16 *pC = (*(u16 * *)&D_80189C00);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C54B0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C54AC != 0) {\n            D_801C54B0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80189BF8;\n    extern u8 D_80189BF4;\n    extern u8 D_80189C00;\n    extern u16 D_801C54B0;\n    extern s16 D_801C54AC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80189BF8);\n    u16 *pB = (*(u16 * *)&D_80189BF4);\n    u16 *pC = (*(u16 * *)&D_80189C00);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C54B0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C54AC != 0) {\n            D_801C54B0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:09", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.251, "objects": ["build/src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801828FC;\n    extern u8 D_801828F8;\n    extern u8 D_80182904;\n    extern u16 D_801C4BF8;\n    extern s16 D_801C4BF4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801828FC);\n    u16 *pB = (*(u16 * *)&D_801828F8);\n    u16 *pC = (*(u16 * *)&D_80182904);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C4BF8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C4BF4 != 0) {\n            D_801C4BF8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801828FC;\n    extern u8 D_801828F8;\n    extern u8 D_80182904;\n    extern u16 D_801C4BF8;\n    extern s16 D_801C4BF4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801828FC);\n    u16 *pB = (*(u16 * *)&D_801828F8);\n    u16 *pC = (*(u16 * *)&D_80182904);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C4BF8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C4BF4 != 0) {\n            D_801C4BF8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:09", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801823E0;\n    extern u8 D_801823DC;\n    extern u8 D_801823E8;\n    extern u16 D_801E07F8;\n    extern s16 D_801E07F4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801823E0);\n    u16 *pB = (*(u16 * *)&D_801823DC);\n    u16 *pC = (*(u16 * *)&D_801823E8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E07F8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E07F4 != 0) {\n            D_801E07F8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801823E0;\n    extern u8 D_801823DC;\n    extern u8 D_801823E8;\n    extern u16 D_801E07F8;\n    extern s16 D_801E07F4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801823E0);\n    u16 *pB = (*(u16 * *)&D_801823DC);\n    u16 *pC = (*(u16 * *)&D_801823E8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E07F8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E07F4 != 0) {\n            D_801E07F8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:10", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.251, "objects": ["build/src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185294;\n    extern u8 D_80185290;\n    extern u8 D_8018529C;\n    extern u16 D_801B1BB0;\n    extern s16 D_801B1BAC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185294);\n    u16 *pB = (*(u16 * *)&D_80185290);\n    u16 *pC = (*(u16 * *)&D_8018529C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B1BB0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B1BAC != 0) {\n            D_801B1BB0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185294;\n    extern u8 D_80185290;\n    extern u8 D_8018529C;\n    extern u16 D_801B1BB0;\n    extern s16 D_801B1BAC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185294);\n    u16 *pB = (*(u16 * *)&D_80185290);\n    u16 *pC = (*(u16 * *)&D_8018529C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B1BB0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B1BAC != 0) {\n            D_801B1BB0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:10", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.255, "objects": ["build/src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018CEC4;\n    extern u8 D_8018CEC0;\n    extern u8 D_8018CECC;\n    extern u16 D_801D0FE8;\n    extern s16 D_801D0FE4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018CEC4);\n    u16 *pB = (*(u16 * *)&D_8018CEC0);\n    u16 *pC = (*(u16 * *)&D_8018CECC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D0FE8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D0FE4 != 0) {\n            D_801D0FE8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018CEC4;\n    extern u8 D_8018CEC0;\n    extern u8 D_8018CECC;\n    extern u16 D_801D0FE8;\n    extern s16 D_801D0FE4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018CEC4);\n    u16 *pB = (*(u16 * *)&D_8018CEC0);\n    u16 *pC = (*(u16 * *)&D_8018CECC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D0FE8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D0FE4 != 0) {\n            D_801D0FE8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:10", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018C01C;\n    extern u8 D_8018C018;\n    extern u8 D_8018C024;\n    extern u16 D_801CA918;\n    extern s16 D_801CA914;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018C01C);\n    u16 *pB = (*(u16 * *)&D_8018C018);\n    u16 *pC = (*(u16 * *)&D_8018C024);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CA918 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CA914 != 0) {\n            D_801CA918 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018C01C;\n    extern u8 D_8018C018;\n    extern u8 D_8018C024;\n    extern u16 D_801CA918;\n    extern s16 D_801CA914;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018C01C);\n    u16 *pB = (*(u16 * *)&D_8018C018);\n    u16 *pC = (*(u16 * *)&D_8018C024);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CA918 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CA914 != 0) {\n            D_801CA918 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:11", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.251, "objects": ["build/src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018646C;\n    extern u8 D_80186468;\n    extern u8 D_80186474;\n    extern u16 D_801CB020;\n    extern s16 D_801CB01C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018646C);\n    u16 *pB = (*(u16 * *)&D_80186468);\n    u16 *pC = (*(u16 * *)&D_80186474);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CB020 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CB01C != 0) {\n            D_801CB020 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018646C;\n    extern u8 D_80186468;\n    extern u8 D_80186474;\n    extern u16 D_801CB020;\n    extern s16 D_801CB01C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018646C);\n    u16 *pB = (*(u16 * *)&D_80186468);\n    u16 *pC = (*(u16 * *)&D_80186474);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CB020 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CB01C != 0) {\n            D_801CB020 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:11", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.25, "objects": ["build/src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80187E68;\n    extern u8 D_80187E64;\n    extern u8 D_80187E70;\n    extern u16 D_801D1E60;\n    extern s16 D_801D1E5C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80187E68);\n    u16 *pB = (*(u16 * *)&D_80187E64);\n    u16 *pC = (*(u16 * *)&D_80187E70);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D1E60 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D1E5C != 0) {\n            D_801D1E60 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80187E68;\n    extern u8 D_80187E64;\n    extern u8 D_80187E70;\n    extern u16 D_801D1E60;\n    extern s16 D_801D1E5C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80187E68);\n    u16 *pB = (*(u16 * *)&D_80187E64);\n    u16 *pC = (*(u16 * *)&D_80187E70);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D1E60 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D1E5C != 0) {\n            D_801D1E60 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:12", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801814C8;\n    extern u8 D_801814C4;\n    extern u8 D_801814D0;\n    extern u16 D_8019AA58;\n    extern s16 D_8019AA54;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801814C8);\n    u16 *pB = (*(u16 * *)&D_801814C4);\n    u16 *pC = (*(u16 * *)&D_801814D0);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019AA58 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019AA54 != 0) {\n            D_8019AA58 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801814C8;\n    extern u8 D_801814C4;\n    extern u8 D_801814D0;\n    extern u16 D_8019AA58;\n    extern s16 D_8019AA54;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801814C8);\n    u16 *pB = (*(u16 * *)&D_801814C4);\n    u16 *pC = (*(u16 * *)&D_801814D0);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019AA58 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019AA54 != 0) {\n            D_8019AA58 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:12", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80181048;\n    extern u8 D_80181044;\n    extern u8 D_80181050;\n    extern u16 D_80199510;\n    extern s16 D_8019950C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80181048);\n    u16 *pB = (*(u16 * *)&D_80181044);\n    u16 *pC = (*(u16 * *)&D_80181050);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80199510 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019950C != 0) {\n            D_80199510 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80181048;\n    extern u8 D_80181044;\n    extern u8 D_80181050;\n    extern u16 D_80199510;\n    extern s16 D_8019950C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80181048);\n    u16 *pB = (*(u16 * *)&D_80181044);\n    u16 *pC = (*(u16 * *)&D_80181050);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80199510 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019950C != 0) {\n            D_80199510 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:12", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186428;\n    extern u8 D_80186424;\n    extern u8 D_80186430;\n    extern u16 D_801A9598;\n    extern s16 D_801A9594;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186428);\n    u16 *pB = (*(u16 * *)&D_80186424);\n    u16 *pC = (*(u16 * *)&D_80186430);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A9598 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A9594 != 0) {\n            D_801A9598 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186428;\n    extern u8 D_80186424;\n    extern u8 D_80186430;\n    extern u16 D_801A9598;\n    extern s16 D_801A9594;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186428);\n    u16 *pB = (*(u16 * *)&D_80186424);\n    u16 *pC = (*(u16 * *)&D_80186430);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A9598 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A9594 != 0) {\n            D_801A9598 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:13", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801858B4;\n    extern u8 D_801858B0;\n    extern u8 D_801858BC;\n    extern u16 D_801C4208;\n    extern s16 D_801C4204;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801858B4);\n    u16 *pB = (*(u16 * *)&D_801858B0);\n    u16 *pC = (*(u16 * *)&D_801858BC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C4208 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C4204 != 0) {\n            D_801C4208 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801858B4;\n    extern u8 D_801858B0;\n    extern u8 D_801858BC;\n    extern u16 D_801C4208;\n    extern s16 D_801C4204;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801858B4);\n    u16 *pB = (*(u16 * *)&D_801858B0);\n    u16 *pC = (*(u16 * *)&D_801858BC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C4208 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C4204 != 0) {\n            D_801C4208 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:13", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80183E5C;\n    extern u8 D_80183E58;\n    extern u8 D_80183E64;\n    extern u16 D_8019CA28;\n    extern s16 D_8019CA24;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80183E5C);\n    u16 *pB = (*(u16 * *)&D_80183E58);\n    u16 *pC = (*(u16 * *)&D_80183E64);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019CA28 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019CA24 != 0) {\n            D_8019CA28 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80183E5C;\n    extern u8 D_80183E58;\n    extern u8 D_80183E64;\n    extern u16 D_8019CA28;\n    extern s16 D_8019CA24;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80183E5C);\n    u16 *pB = (*(u16 * *)&D_80183E58);\n    u16 *pC = (*(u16 * *)&D_80183E64);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019CA28 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019CA24 != 0) {\n            D_8019CA28 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:13", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.251, "objects": ["build/src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184E80;\n    extern u8 D_80184E7C;\n    extern u8 D_80184E88;\n    extern u16 D_801C7160;\n    extern s16 D_801C715C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184E80);\n    u16 *pB = (*(u16 * *)&D_80184E7C);\n    u16 *pC = (*(u16 * *)&D_80184E88);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C7160 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C715C != 0) {\n            D_801C7160 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184E80;\n    extern u8 D_80184E7C;\n    extern u8 D_80184E88;\n    extern u16 D_801C7160;\n    extern s16 D_801C715C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184E80);\n    u16 *pB = (*(u16 * *)&D_80184E7C);\n    u16 *pC = (*(u16 * *)&D_80184E88);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C7160 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C715C != 0) {\n            D_801C7160 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:14", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.253, "objects": ["build/src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801839B4;\n    extern u8 D_801839B0;\n    extern u8 D_801839BC;\n    extern u16 D_801BDED8;\n    extern s16 D_801BDED4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801839B4);\n    u16 *pB = (*(u16 * *)&D_801839B0);\n    u16 *pC = (*(u16 * *)&D_801839BC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801BDED8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801BDED4 != 0) {\n            D_801BDED8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801839B4;\n    extern u8 D_801839B0;\n    extern u8 D_801839BC;\n    extern u16 D_801BDED8;\n    extern s16 D_801BDED4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801839B4);\n    u16 *pB = (*(u16 * *)&D_801839B0);\n    u16 *pC = (*(u16 * *)&D_801839BC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801BDED8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801BDED4 != 0) {\n            D_801BDED8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:14", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.262, "objects": ["build/src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186714;\n    extern u8 D_80186710;\n    extern u8 D_8018671C;\n    extern u16 D_801B86A0;\n    extern s16 D_801B869C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186714);\n    u16 *pB = (*(u16 * *)&D_80186710);\n    u16 *pC = (*(u16 * *)&D_8018671C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B86A0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B869C != 0) {\n            D_801B86A0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186714;\n    extern u8 D_80186710;\n    extern u8 D_8018671C;\n    extern u16 D_801B86A0;\n    extern s16 D_801B869C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186714);\n    u16 *pB = (*(u16 * *)&D_80186710);\n    u16 *pC = (*(u16 * *)&D_8018671C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B86A0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B869C != 0) {\n            D_801B86A0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:14", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.25, "objects": ["build/src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801846C4;\n    extern u8 D_801846C0;\n    extern u8 D_801846CC;\n    extern u16 D_801C3858;\n    extern s16 D_801C3854;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801846C4);\n    u16 *pB = (*(u16 * *)&D_801846C0);\n    u16 *pC = (*(u16 * *)&D_801846CC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C3858 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C3854 != 0) {\n            D_801C3858 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801846C4;\n    extern u8 D_801846C0;\n    extern u8 D_801846CC;\n    extern u16 D_801C3858;\n    extern s16 D_801C3854;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801846C4);\n    u16 *pB = (*(u16 * *)&D_801846C0);\n    u16 *pC = (*(u16 * *)&D_801846CC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C3858 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C3854 != 0) {\n            D_801C3858 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:15", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.255, "objects": ["build/src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018B254;\n    extern u8 D_8018B250;\n    extern u8 D_8018B25C;\n    extern u16 D_801BEDF0;\n    extern s16 D_801BEDEC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018B254);\n    u16 *pB = (*(u16 * *)&D_8018B250);\n    u16 *pC = (*(u16 * *)&D_8018B25C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801BEDF0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801BEDEC != 0) {\n            D_801BEDF0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018B254;\n    extern u8 D_8018B250;\n    extern u8 D_8018B25C;\n    extern u16 D_801BEDF0;\n    extern s16 D_801BEDEC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018B254);\n    u16 *pB = (*(u16 * *)&D_8018B250);\n    u16 *pC = (*(u16 * *)&D_8018B25C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801BEDF0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801BEDEC != 0) {\n            D_801BEDF0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:15", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.26, "objects": ["build/src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018A8DC;\n    extern u8 D_8018A8D8;\n    extern u8 D_8018A8E4;\n    extern u16 D_801B8380;\n    extern s16 D_801B837C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018A8DC);\n    u16 *pB = (*(u16 * *)&D_8018A8D8);\n    u16 *pC = (*(u16 * *)&D_8018A8E4);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B8380 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B837C != 0) {\n            D_801B8380 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018A8DC;\n    extern u8 D_8018A8D8;\n    extern u8 D_8018A8E4;\n    extern u16 D_801B8380;\n    extern s16 D_801B837C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018A8DC);\n    u16 *pB = (*(u16 * *)&D_8018A8D8);\n    u16 *pC = (*(u16 * *)&D_8018A8E4);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B8380 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B837C != 0) {\n            D_801B8380 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:15", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.251, "objects": ["build/src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80181234;\n    extern u8 D_80181230;\n    extern u8 D_8018123C;\n    extern u16 D_801A0670;\n    extern s16 D_801A066C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80181234);\n    u16 *pB = (*(u16 * *)&D_80181230);\n    u16 *pC = (*(u16 * *)&D_8018123C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A0670 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A066C != 0) {\n            D_801A0670 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80181234;\n    extern u8 D_80181230;\n    extern u8 D_8018123C;\n    extern u16 D_801A0670;\n    extern s16 D_801A066C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80181234);\n    u16 *pB = (*(u16 * *)&D_80181230);\n    u16 *pC = (*(u16 * *)&D_8018123C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A0670 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A066C != 0) {\n            D_801A0670 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:16", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.257, "objects": ["build/src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E8E0;\n    extern u8 D_8017E8DC;\n    extern u8 D_8017E8E8;\n    extern u16 D_80199080;\n    extern s16 D_8019907C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E8E0);\n    u16 *pB = (*(u16 * *)&D_8017E8DC);\n    u16 *pC = (*(u16 * *)&D_8017E8E8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80199080 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019907C != 0) {\n            D_80199080 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E8E0;\n    extern u8 D_8017E8DC;\n    extern u8 D_8017E8E8;\n    extern u16 D_80199080;\n    extern s16 D_8019907C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E8E0);\n    u16 *pB = (*(u16 * *)&D_8017E8DC);\n    u16 *pC = (*(u16 * *)&D_8017E8E8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80199080 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019907C != 0) {\n            D_80199080 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:16", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.253, "objects": ["build/src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182300;\n    extern u8 D_801822FC;\n    extern u8 D_80182308;\n    extern u16 D_801A0E28;\n    extern s16 D_801A0E24;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182300);\n    u16 *pB = (*(u16 * *)&D_801822FC);\n    u16 *pC = (*(u16 * *)&D_80182308);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A0E28 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A0E24 != 0) {\n            D_801A0E28 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182300;\n    extern u8 D_801822FC;\n    extern u8 D_80182308;\n    extern u16 D_801A0E28;\n    extern s16 D_801A0E24;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182300);\n    u16 *pB = (*(u16 * *)&D_801822FC);\n    u16 *pC = (*(u16 * *)&D_80182308);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A0E28 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A0E24 != 0) {\n            D_801A0E28 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:16", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.251, "objects": ["build/src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184EB4;\n    extern u8 D_80184EB0;\n    extern u8 D_80184EBC;\n    extern u16 D_801B8330;\n    extern s16 D_801B832C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184EB4);\n    u16 *pB = (*(u16 * *)&D_80184EB0);\n    u16 *pC = (*(u16 * *)&D_80184EBC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B8330 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B832C != 0) {\n            D_801B8330 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184EB4;\n    extern u8 D_80184EB0;\n    extern u8 D_80184EBC;\n    extern u16 D_801B8330;\n    extern s16 D_801B832C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184EB4);\n    u16 *pB = (*(u16 * *)&D_80184EB0);\n    u16 *pC = (*(u16 * *)&D_80184EBC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B8330 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B832C != 0) {\n            D_801B8330 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:17", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.25, "objects": ["build/src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185CBC;\n    extern u8 D_80185CB8;\n    extern u8 D_80185CC4;\n    extern u16 D_801ABB90;\n    extern s16 D_801ABB8C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185CBC);\n    u16 *pB = (*(u16 * *)&D_80185CB8);\n    u16 *pC = (*(u16 * *)&D_80185CC4);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801ABB90 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801ABB8C != 0) {\n            D_801ABB90 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185CBC;\n    extern u8 D_80185CB8;\n    extern u8 D_80185CC4;\n    extern u16 D_801ABB90;\n    extern s16 D_801ABB8C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185CBC);\n    u16 *pB = (*(u16 * *)&D_80185CB8);\n    u16 *pC = (*(u16 * *)&D_80185CC4);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801ABB90 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801ABB8C != 0) {\n            D_801ABB90 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:17", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.249, "objects": ["build/src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017EFD4;\n    extern u8 D_8017EFD0;\n    extern u8 D_8017EFDC;\n    extern u16 D_801A83B8;\n    extern s16 D_801A83B4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017EFD4);\n    u16 *pB = (*(u16 * *)&D_8017EFD0);\n    u16 *pC = (*(u16 * *)&D_8017EFDC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A83B8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A83B4 != 0) {\n            D_801A83B8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017EFD4;\n    extern u8 D_8017EFD0;\n    extern u8 D_8017EFDC;\n    extern u16 D_801A83B8;\n    extern s16 D_801A83B4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017EFD4);\n    u16 *pB = (*(u16 * *)&D_8017EFD0);\n    u16 *pC = (*(u16 * *)&D_8017EFDC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A83B8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A83B4 != 0) {\n            D_801A83B8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:17", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.249, "objects": ["build/src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80180A40;\n    extern u8 D_80180A3C;\n    extern u8 D_80180A48;\n    extern u16 D_80193D10;\n    extern s16 D_80193D0C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80180A40);\n    u16 *pB = (*(u16 * *)&D_80180A3C);\n    u16 *pC = (*(u16 * *)&D_80180A48);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80193D10 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80193D0C != 0) {\n            D_80193D10 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80180A40;\n    extern u8 D_80180A3C;\n    extern u8 D_80180A48;\n    extern u16 D_80193D10;\n    extern s16 D_80193D0C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80180A40);\n    u16 *pB = (*(u16 * *)&D_80180A3C);\n    u16 *pC = (*(u16 * *)&D_80180A48);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80193D10 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80193D0C != 0) {\n            D_80193D10 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:18", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018336C;\n    extern u8 D_80183368;\n    extern u8 D_80183374;\n    extern u16 D_801A4720;\n    extern s16 D_801A471C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018336C);\n    u16 *pB = (*(u16 * *)&D_80183368);\n    u16 *pC = (*(u16 * *)&D_80183374);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A4720 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A471C != 0) {\n            D_801A4720 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018336C;\n    extern u8 D_80183368;\n    extern u8 D_80183374;\n    extern u16 D_801A4720;\n    extern s16 D_801A471C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018336C);\n    u16 *pB = (*(u16 * *)&D_80183368);\n    u16 *pC = (*(u16 * *)&D_80183374);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A4720 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A471C != 0) {\n            D_801A4720 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:18", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.253, "objects": ["build/src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182E44;\n    extern u8 D_80182E40;\n    extern u8 D_80182E4C;\n    extern u16 D_801968A0;\n    extern s16 D_8019689C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182E44);\n    u16 *pB = (*(u16 * *)&D_80182E40);\n    u16 *pC = (*(u16 * *)&D_80182E4C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801968A0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019689C != 0) {\n            D_801968A0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182E44;\n    extern u8 D_80182E40;\n    extern u8 D_80182E4C;\n    extern u16 D_801968A0;\n    extern s16 D_8019689C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182E44);\n    u16 *pB = (*(u16 * *)&D_80182E40);\n    u16 *pC = (*(u16 * *)&D_80182E4C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801968A0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019689C != 0) {\n            D_801968A0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:18", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.25, "objects": ["build/src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182718;\n    extern u8 D_80182714;\n    extern u8 D_80182720;\n    extern u16 D_801ADA10;\n    extern s16 D_801ADA0C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182718);\n    u16 *pB = (*(u16 * *)&D_80182714);\n    u16 *pC = (*(u16 * *)&D_80182720);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801ADA10 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801ADA0C != 0) {\n            D_801ADA10 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182718;\n    extern u8 D_80182714;\n    extern u8 D_80182720;\n    extern u16 D_801ADA10;\n    extern s16 D_801ADA0C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182718);\n    u16 *pB = (*(u16 * *)&D_80182714);\n    u16 *pC = (*(u16 * *)&D_80182720);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801ADA10 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801ADA0C != 0) {\n            D_801ADA10 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:19", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.258, "objects": ["build/src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184E50;\n    extern u8 D_80184E4C;\n    extern u8 D_80184E58;\n    extern u16 D_801CD018;\n    extern s16 D_801CD014;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184E50);\n    u16 *pB = (*(u16 * *)&D_80184E4C);\n    u16 *pC = (*(u16 * *)&D_80184E58);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CD018 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CD014 != 0) {\n            D_801CD018 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184E50;\n    extern u8 D_80184E4C;\n    extern u8 D_80184E58;\n    extern u16 D_801CD018;\n    extern s16 D_801CD014;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184E50);\n    u16 *pB = (*(u16 * *)&D_80184E4C);\n    u16 *pC = (*(u16 * *)&D_80184E58);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CD018 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CD014 != 0) {\n            D_801CD018 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:19", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.253, "objects": ["build/src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184314;\n    extern u8 D_80184310;\n    extern u8 D_8018431C;\n    extern u16 D_801C2E30;\n    extern s16 D_801C2E2C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184314);\n    u16 *pB = (*(u16 * *)&D_80184310);\n    u16 *pC = (*(u16 * *)&D_8018431C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C2E30 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C2E2C != 0) {\n            D_801C2E30 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184314;\n    extern u8 D_80184310;\n    extern u8 D_8018431C;\n    extern u16 D_801C2E30;\n    extern s16 D_801C2E2C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184314);\n    u16 *pB = (*(u16 * *)&D_80184310);\n    u16 *pC = (*(u16 * *)&D_8018431C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C2E30 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C2E2C != 0) {\n            D_801C2E30 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:19", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.257, "objects": ["build/src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018B144;\n    extern u8 D_8018B140;\n    extern u8 D_8018B14C;\n    extern u16 D_801E0538;\n    extern s16 D_801E0534;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018B144);\n    u16 *pB = (*(u16 * *)&D_8018B140);\n    u16 *pC = (*(u16 * *)&D_8018B14C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E0538 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E0534 != 0) {\n            D_801E0538 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018B144;\n    extern u8 D_8018B140;\n    extern u8 D_8018B14C;\n    extern u16 D_801E0538;\n    extern s16 D_801E0534;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018B144);\n    u16 *pB = (*(u16 * *)&D_8018B140);\n    u16 *pC = (*(u16 * *)&D_8018B14C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E0538 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E0534 != 0) {\n            D_801E0538 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:20", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.254, "objects": ["build/src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80183818;\n    extern u8 D_80183814;\n    extern u8 D_80183820;\n    extern u16 D_801A87A8;\n    extern s16 D_801A87A4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80183818);\n    u16 *pB = (*(u16 * *)&D_80183814);\n    u16 *pC = (*(u16 * *)&D_80183820);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A87A8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A87A4 != 0) {\n            D_801A87A8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80183818;\n    extern u8 D_80183814;\n    extern u8 D_80183820;\n    extern u16 D_801A87A8;\n    extern s16 D_801A87A4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80183818);\n    u16 *pB = (*(u16 * *)&D_80183814);\n    u16 *pC = (*(u16 * *)&D_80183820);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A87A8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A87A4 != 0) {\n            D_801A87A8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:20", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.249, "objects": ["build/src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80188984;\n    extern u8 D_80188980;\n    extern u8 D_8018898C;\n    extern u16 D_801BFAB8;\n    extern s16 D_801BFAB4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80188984);\n    u16 *pB = (*(u16 * *)&D_80188980);\n    u16 *pC = (*(u16 * *)&D_8018898C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801BFAB8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801BFAB4 != 0) {\n            D_801BFAB8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80188984;\n    extern u8 D_80188980;\n    extern u8 D_8018898C;\n    extern u16 D_801BFAB8;\n    extern s16 D_801BFAB4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80188984);\n    u16 *pB = (*(u16 * *)&D_80188980);\n    u16 *pC = (*(u16 * *)&D_8018898C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801BFAB8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801BFAB4 != 0) {\n            D_801BFAB8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:20", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.249, "objects": ["build/src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182720;\n    extern u8 D_8018271C;\n    extern u8 D_80182728;\n    extern u16 D_8019A720;\n    extern s16 D_8019A71C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182720);\n    u16 *pB = (*(u16 * *)&D_8018271C);\n    u16 *pC = (*(u16 * *)&D_80182728);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019A720 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019A71C != 0) {\n            D_8019A720 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182720;\n    extern u8 D_8018271C;\n    extern u8 D_80182728;\n    extern u16 D_8019A720;\n    extern s16 D_8019A71C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182720);\n    u16 *pB = (*(u16 * *)&D_8018271C);\n    u16 *pC = (*(u16 * *)&D_80182728);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019A720 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019A71C != 0) {\n            D_8019A720 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:21", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.25, "objects": ["build/src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184C54;\n    extern u8 D_80184C50;\n    extern u8 D_80184C5C;\n    extern u16 D_801B2520;\n    extern s16 D_801B251C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184C54);\n    u16 *pB = (*(u16 * *)&D_80184C50);\n    u16 *pC = (*(u16 * *)&D_80184C5C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B2520 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B251C != 0) {\n            D_801B2520 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184C54;\n    extern u8 D_80184C50;\n    extern u8 D_80184C5C;\n    extern u16 D_801B2520;\n    extern s16 D_801B251C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184C54);\n    u16 *pB = (*(u16 * *)&D_80184C50);\n    u16 *pC = (*(u16 * *)&D_80184C5C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B2520 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B251C != 0) {\n            D_801B2520 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:21", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.502, "objects": ["build/src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.o", "build/src/ov_SC03_119/ov_SC03_119_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80189EFC;\n    extern u8 D_80189EF8;\n    extern u8 D_80189F04;\n    extern u16 D_801D2F68;\n    extern s16 D_801D2F64;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80189EFC);\n    u16 *pB = (*(u16 * *)&D_80189EF8);\n    u16 *pC = (*(u16 * *)&D_80189F04);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D2F68 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D2F64 != 0) {\n            D_801D2F68 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80189EFC;\n    extern u8 D_80189EF8;\n    extern u8 D_80189F04;\n    extern u16 D_801D2F68;\n    extern s16 D_801D2F64;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80189EFC);\n    u16 *pB = (*(u16 * *)&D_80189EF8);\n    u16 *pC = (*(u16 * *)&D_80189F04);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801D2F68 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801D2F64 != 0) {\n            D_801D2F68 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:22", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.251, "objects": ["build/src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80180168;\n    extern u8 D_80180164;\n    extern u8 D_80180170;\n    extern u16 D_8019C9A0;\n    extern s16 D_8019C99C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80180168);\n    u16 *pB = (*(u16 * *)&D_80180164);\n    u16 *pC = (*(u16 * *)&D_80180170);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019C9A0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019C99C != 0) {\n            D_8019C9A0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80180168;\n    extern u8 D_80180164;\n    extern u8 D_80180170;\n    extern u16 D_8019C9A0;\n    extern s16 D_8019C99C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80180168);\n    u16 *pB = (*(u16 * *)&D_80180164);\n    u16 *pC = (*(u16 * *)&D_80180170);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019C9A0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019C99C != 0) {\n            D_8019C9A0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:22", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.248, "objects": ["build/src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186120;\n    extern u8 D_8018611C;\n    extern u8 D_80186128;\n    extern u16 D_801B3F58;\n    extern s16 D_801B3F54;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186120);\n    u16 *pB = (*(u16 * *)&D_8018611C);\n    u16 *pC = (*(u16 * *)&D_80186128);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B3F58 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B3F54 != 0) {\n            D_801B3F58 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186120;\n    extern u8 D_8018611C;\n    extern u8 D_80186128;\n    extern u16 D_801B3F58;\n    extern s16 D_801B3F54;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186120);\n    u16 *pB = (*(u16 * *)&D_8018611C);\n    u16 *pC = (*(u16 * *)&D_80186128);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B3F58 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B3F54 != 0) {\n            D_801B3F58 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:22", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80188088;\n    extern u8 D_80188084;\n    extern u8 D_80188090;\n    extern u16 D_801C06F8;\n    extern s16 D_801C06F4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80188088);\n    u16 *pB = (*(u16 * *)&D_80188084);\n    u16 *pC = (*(u16 * *)&D_80188090);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C06F8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C06F4 != 0) {\n            D_801C06F8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80188088;\n    extern u8 D_80188084;\n    extern u8 D_80188090;\n    extern u16 D_801C06F8;\n    extern s16 D_801C06F4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80188088);\n    u16 *pB = (*(u16 * *)&D_80188084);\n    u16 *pC = (*(u16 * *)&D_80188090);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C06F8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C06F4 != 0) {\n            D_801C06F8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:23", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F058;\n    extern u8 D_8017F054;\n    extern u8 D_8017F060;\n    extern u16 D_80190C30;\n    extern s16 D_80190C2C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F058);\n    u16 *pB = (*(u16 * *)&D_8017F054);\n    u16 *pC = (*(u16 * *)&D_8017F060);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80190C30 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80190C2C != 0) {\n            D_80190C30 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F058;\n    extern u8 D_8017F054;\n    extern u8 D_8017F060;\n    extern u16 D_80190C30;\n    extern s16 D_80190C2C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F058);\n    u16 *pB = (*(u16 * *)&D_8017F054);\n    u16 *pC = (*(u16 * *)&D_8017F060);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80190C30 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80190C2C != 0) {\n            D_80190C30 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:23", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E730;\n    extern u8 D_8017E72C;\n    extern u8 D_8017E738;\n    extern u16 D_8018E2D8;\n    extern s16 D_8018E2D4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E730);\n    u16 *pB = (*(u16 * *)&D_8017E72C);\n    u16 *pC = (*(u16 * *)&D_8017E738);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018E2D8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018E2D4 != 0) {\n            D_8018E2D8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E730;\n    extern u8 D_8017E72C;\n    extern u8 D_8017E738;\n    extern u16 D_8018E2D8;\n    extern s16 D_8018E2D4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E730);\n    u16 *pB = (*(u16 * *)&D_8017E72C);\n    u16 *pC = (*(u16 * *)&D_8017E738);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018E2D8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018E2D4 != 0) {\n            D_8018E2D8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:23", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017EB94;\n    extern u8 D_8017EB90;\n    extern u8 D_8017EB9C;\n    extern u16 D_801909B0;\n    extern s16 D_801909AC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017EB94);\n    u16 *pB = (*(u16 * *)&D_8017EB90);\n    u16 *pC = (*(u16 * *)&D_8017EB9C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801909B0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801909AC != 0) {\n            D_801909B0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017EB94;\n    extern u8 D_8017EB90;\n    extern u8 D_8017EB9C;\n    extern u16 D_801909B0;\n    extern s16 D_801909AC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017EB94);\n    u16 *pB = (*(u16 * *)&D_8017EB90);\n    u16 *pC = (*(u16 * *)&D_8017EB9C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801909B0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801909AC != 0) {\n            D_801909B0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:24", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.249, "objects": ["build/src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F084;\n    extern u8 D_8017F080;\n    extern u8 D_8017F08C;\n    extern u16 D_80196E40;\n    extern s16 D_80196E3C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F084);\n    u16 *pB = (*(u16 * *)&D_8017F080);\n    u16 *pC = (*(u16 * *)&D_8017F08C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80196E40 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80196E3C != 0) {\n            D_80196E40 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F084;\n    extern u8 D_8017F080;\n    extern u8 D_8017F08C;\n    extern u16 D_80196E40;\n    extern s16 D_80196E3C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F084);\n    u16 *pB = (*(u16 * *)&D_8017F080);\n    u16 *pC = (*(u16 * *)&D_8017F08C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80196E40 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80196E3C != 0) {\n            D_80196E40 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:24", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.277, "objects": ["build/src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184ACC;\n    extern u8 D_80184AC8;\n    extern u8 D_80184AD4;\n    extern u16 D_801C7698;\n    extern s16 D_801C7694;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184ACC);\n    u16 *pB = (*(u16 * *)&D_80184AC8);\n    u16 *pC = (*(u16 * *)&D_80184AD4);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C7698 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C7694 != 0) {\n            D_801C7698 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80184ACC;\n    extern u8 D_80184AC8;\n    extern u8 D_80184AD4;\n    extern u16 D_801C7698;\n    extern s16 D_801C7694;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80184ACC);\n    u16 *pB = (*(u16 * *)&D_80184AC8);\n    u16 *pC = (*(u16 * *)&D_80184AD4);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C7698 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C7694 != 0) {\n            D_801C7698 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:24", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.258, "objects": ["build/src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80180590;\n    extern u8 D_8018058C;\n    extern u8 D_80180598;\n    extern u16 D_801A5840;\n    extern s16 D_801A583C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80180590);\n    u16 *pB = (*(u16 * *)&D_8018058C);\n    u16 *pC = (*(u16 * *)&D_80180598);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A5840 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A583C != 0) {\n            D_801A5840 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80180590;\n    extern u8 D_8018058C;\n    extern u8 D_80180598;\n    extern u16 D_801A5840;\n    extern s16 D_801A583C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80180590);\n    u16 *pB = (*(u16 * *)&D_8018058C);\n    u16 *pC = (*(u16 * *)&D_80180598);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A5840 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A583C != 0) {\n            D_801A5840 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:25", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.255, "objects": ["build/src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801838E0;\n    extern u8 D_801838DC;\n    extern u8 D_801838E8;\n    extern u16 D_801BB0A0;\n    extern s16 D_801BB09C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801838E0);\n    u16 *pB = (*(u16 * *)&D_801838DC);\n    u16 *pC = (*(u16 * *)&D_801838E8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801BB0A0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801BB09C != 0) {\n            D_801BB0A0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801838E0;\n    extern u8 D_801838DC;\n    extern u8 D_801838E8;\n    extern u16 D_801BB0A0;\n    extern s16 D_801BB09C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801838E0);\n    u16 *pB = (*(u16 * *)&D_801838DC);\n    u16 *pC = (*(u16 * *)&D_801838E8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801BB0A0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801BB09C != 0) {\n            D_801BB0A0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:25", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.277, "objects": ["build/src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E820;\n    extern u8 D_8017E81C;\n    extern u8 D_8017E828;\n    extern u16 D_80199828;\n    extern s16 D_80199824;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E820);\n    u16 *pB = (*(u16 * *)&D_8017E81C);\n    u16 *pC = (*(u16 * *)&D_8017E828);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80199828 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80199824 != 0) {\n            D_80199828 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E820;\n    extern u8 D_8017E81C;\n    extern u8 D_8017E828;\n    extern u16 D_80199828;\n    extern s16 D_80199824;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E820);\n    u16 *pB = (*(u16 * *)&D_8017E81C);\n    u16 *pC = (*(u16 * *)&D_8017E828);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80199828 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80199824 != 0) {\n            D_80199828 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:26", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.248, "objects": ["build/src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185FFC;\n    extern u8 D_80185FF8;\n    extern u8 D_80186004;\n    extern u16 D_801B48E8;\n    extern s16 D_801B48E4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185FFC);\n    u16 *pB = (*(u16 * *)&D_80185FF8);\n    u16 *pC = (*(u16 * *)&D_80186004);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B48E8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B48E4 != 0) {\n            D_801B48E8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185FFC;\n    extern u8 D_80185FF8;\n    extern u8 D_80186004;\n    extern u16 D_801B48E8;\n    extern s16 D_801B48E4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185FFC);\n    u16 *pB = (*(u16 * *)&D_80185FF8);\n    u16 *pC = (*(u16 * *)&D_80186004);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B48E8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B48E4 != 0) {\n            D_801B48E8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:26", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.249, "objects": ["build/src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182AF4;\n    extern u8 D_80182AF0;\n    extern u8 D_80182AFC;\n    extern u16 D_801AB698;\n    extern s16 D_801AB694;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182AF4);\n    u16 *pB = (*(u16 * *)&D_80182AF0);\n    u16 *pC = (*(u16 * *)&D_80182AFC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801AB698 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801AB694 != 0) {\n            D_801AB698 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182AF4;\n    extern u8 D_80182AF0;\n    extern u8 D_80182AFC;\n    extern u16 D_801AB698;\n    extern s16 D_801AB694;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182AF4);\n    u16 *pB = (*(u16 * *)&D_80182AF0);\n    u16 *pC = (*(u16 * *)&D_80182AFC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801AB698 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801AB694 != 0) {\n            D_801AB698 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:26", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801829D4;\n    extern u8 D_801829D0;\n    extern u8 D_801829DC;\n    extern u16 D_801B0978;\n    extern s16 D_801B0974;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801829D4);\n    u16 *pB = (*(u16 * *)&D_801829D0);\n    u16 *pC = (*(u16 * *)&D_801829DC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B0978 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B0974 != 0) {\n            D_801B0978 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801829D4;\n    extern u8 D_801829D0;\n    extern u8 D_801829DC;\n    extern u16 D_801B0978;\n    extern s16 D_801B0974;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801829D4);\n    u16 *pB = (*(u16 * *)&D_801829D0);\n    u16 *pC = (*(u16 * *)&D_801829DC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B0978 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B0974 != 0) {\n            D_801B0978 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:27", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801807BC;\n    extern u8 D_801807B8;\n    extern u8 D_801807C4;\n    extern u16 D_8019EB88;\n    extern s16 D_8019EB84;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801807BC);\n    u16 *pB = (*(u16 * *)&D_801807B8);\n    u16 *pC = (*(u16 * *)&D_801807C4);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019EB88 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019EB84 != 0) {\n            D_8019EB88 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801807BC;\n    extern u8 D_801807B8;\n    extern u8 D_801807C4;\n    extern u16 D_8019EB88;\n    extern s16 D_8019EB84;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801807BC);\n    u16 *pB = (*(u16 * *)&D_801807B8);\n    u16 *pC = (*(u16 * *)&D_801807C4);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019EB88 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019EB84 != 0) {\n            D_8019EB88 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:27", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80181C00;\n    extern u8 D_80181BFC;\n    extern u8 D_80181C08;\n    extern u16 D_8019DD10;\n    extern s16 D_8019DD0C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80181C00);\n    u16 *pB = (*(u16 * *)&D_80181BFC);\n    u16 *pC = (*(u16 * *)&D_80181C08);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019DD10 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019DD0C != 0) {\n            D_8019DD10 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80181C00;\n    extern u8 D_80181BFC;\n    extern u8 D_80181C08;\n    extern u16 D_8019DD10;\n    extern s16 D_8019DD0C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80181C00);\n    u16 *pB = (*(u16 * *)&D_80181BFC);\n    u16 *pC = (*(u16 * *)&D_80181C08);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019DD10 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019DD0C != 0) {\n            D_8019DD10 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:27", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F9F4;\n    extern u8 D_8017F9F0;\n    extern u8 D_8017F9FC;\n    extern u16 D_8018EAB0;\n    extern s16 D_8018EAAC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F9F4);\n    u16 *pB = (*(u16 * *)&D_8017F9F0);\n    u16 *pC = (*(u16 * *)&D_8017F9FC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018EAB0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018EAAC != 0) {\n            D_8018EAB0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F9F4;\n    extern u8 D_8017F9F0;\n    extern u8 D_8017F9FC;\n    extern u16 D_8018EAB0;\n    extern s16 D_8018EAAC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F9F4);\n    u16 *pB = (*(u16 * *)&D_8017F9F0);\n    u16 *pC = (*(u16 * *)&D_8017F9FC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018EAB0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018EAAC != 0) {\n            D_8018EAB0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:28", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182F48;\n    extern u8 D_80182F44;\n    extern u8 D_80182F50;\n    extern u16 D_8019FDC0;\n    extern s16 D_8019FDBC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182F48);\n    u16 *pB = (*(u16 * *)&D_80182F44);\n    u16 *pC = (*(u16 * *)&D_80182F50);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019FDC0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019FDBC != 0) {\n            D_8019FDC0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182F48;\n    extern u8 D_80182F44;\n    extern u8 D_80182F50;\n    extern u16 D_8019FDC0;\n    extern s16 D_8019FDBC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182F48);\n    u16 *pB = (*(u16 * *)&D_80182F44);\n    u16 *pC = (*(u16 * *)&D_80182F50);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019FDC0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019FDBC != 0) {\n            D_8019FDC0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:28", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80180FF0;\n    extern u8 D_80180FEC;\n    extern u8 D_80180FF8;\n    extern u16 D_8019BA90;\n    extern s16 D_8019BA8C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80180FF0);\n    u16 *pB = (*(u16 * *)&D_80180FEC);\n    u16 *pC = (*(u16 * *)&D_80180FF8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019BA90 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019BA8C != 0) {\n            D_8019BA90 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80180FF0;\n    extern u8 D_80180FEC;\n    extern u8 D_80180FF8;\n    extern u16 D_8019BA90;\n    extern s16 D_8019BA8C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80180FF0);\n    u16 *pB = (*(u16 * *)&D_80180FEC);\n    u16 *pC = (*(u16 * *)&D_80180FF8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019BA90 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019BA8C != 0) {\n            D_8019BA90 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:28", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_107/ov_SC03_107_jr_80131340.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.121, "objects": ["build/src/ov_SC03_107/ov_SC03_107_jr_80131340.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182A3C;\n    extern u8 D_80182A38;\n    extern u8 D_80182A44;\n    extern u16 D_8019A788;\n    extern s16 D_8019A784;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182A3C);\n    u16 *pB = (*(u16 * *)&D_80182A38);\n    u16 *pC = (*(u16 * *)&D_80182A44);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019A788 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019A784 != 0) {\n            D_8019A788 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182A3C;\n    extern u8 D_80182A38;\n    extern u8 D_80182A44;\n    extern u16 D_8019A788;\n    extern s16 D_8019A784;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182A3C);\n    u16 *pB = (*(u16 * *)&D_80182A38);\n    u16 *pC = (*(u16 * *)&D_80182A44);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019A788 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019A784 != 0) {\n            D_8019A788 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:28", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F058;\n    extern u8 D_8017F054;\n    extern u8 D_8017F060;\n    extern u16 D_801957D0;\n    extern s16 D_801957CC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F058);\n    u16 *pB = (*(u16 * *)&D_8017F054);\n    u16 *pC = (*(u16 * *)&D_8017F060);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801957D0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801957CC != 0) {\n            D_801957D0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F058;\n    extern u8 D_8017F054;\n    extern u8 D_8017F060;\n    extern u16 D_801957D0;\n    extern s16 D_801957CC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F058);\n    u16 *pB = (*(u16 * *)&D_8017F054);\n    u16 *pC = (*(u16 * *)&D_8017F060);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801957D0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801957CC != 0) {\n            D_801957D0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:29", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.488, "objects": ["build/src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.o", "build/src/ov_SC04_019/ov_SC04_019_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018D7A8;\n    extern u8 D_8018D7A4;\n    extern u8 D_8018D7B0;\n    extern u16 D_801E5A90;\n    extern s16 D_801E5A8C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018D7A8);\n    u16 *pB = (*(u16 * *)&D_8018D7A4);\n    u16 *pC = (*(u16 * *)&D_8018D7B0);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E5A90 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E5A8C != 0) {\n            D_801E5A90 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018D7A8;\n    extern u8 D_8018D7A4;\n    extern u8 D_8018D7B0;\n    extern u16 D_801E5A90;\n    extern s16 D_801E5A8C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018D7A8);\n    u16 *pB = (*(u16 * *)&D_8018D7A4);\n    u16 *pC = (*(u16 * *)&D_8018D7B0);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801E5A90 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801E5A8C != 0) {\n            D_801E5A90 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:29", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80188F34;\n    extern u8 D_80188F30;\n    extern u8 D_80188F3C;\n    extern u16 D_801C5C20;\n    extern s16 D_801C5C1C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80188F34);\n    u16 *pB = (*(u16 * *)&D_80188F30);\n    u16 *pC = (*(u16 * *)&D_80188F3C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C5C20 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C5C1C != 0) {\n            D_801C5C20 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80188F34;\n    extern u8 D_80188F30;\n    extern u8 D_80188F3C;\n    extern u16 D_801C5C20;\n    extern s16 D_801C5C1C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80188F34);\n    u16 *pB = (*(u16 * *)&D_80188F30);\n    u16 *pC = (*(u16 * *)&D_80188F3C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C5C20 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C5C1C != 0) {\n            D_801C5C20 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:30", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_006/ov_SC07_006_jr_80131340.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.119, "objects": ["build/src/ov_SC07_006/ov_SC07_006_jr_80131340.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018A9A0;\n    extern u8 D_8018A99C;\n    extern u8 D_8018A9A8;\n    extern u16 D_801F4DD8;\n    extern s16 D_801F4DD4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018A9A0);\n    u16 *pB = (*(u16 * *)&D_8018A99C);\n    u16 *pC = (*(u16 * *)&D_8018A9A8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801F4DD8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801F4DD4 != 0) {\n            D_801F4DD8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018A9A0;\n    extern u8 D_8018A99C;\n    extern u8 D_8018A9A8;\n    extern u16 D_801F4DD8;\n    extern s16 D_801F4DD4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018A9A0);\n    u16 *pB = (*(u16 * *)&D_8018A99C);\n    u16 *pC = (*(u16 * *)&D_8018A9A8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801F4DD8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801F4DD4 != 0) {\n            D_801F4DD8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:30", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185228;\n    extern u8 D_80185224;\n    extern u8 D_80185230;\n    extern u16 D_801B0020;\n    extern s16 D_801B001C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185228);\n    u16 *pB = (*(u16 * *)&D_80185224);\n    u16 *pC = (*(u16 * *)&D_80185230);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B0020 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B001C != 0) {\n            D_801B0020 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80185228;\n    extern u8 D_80185224;\n    extern u8 D_80185230;\n    extern u16 D_801B0020;\n    extern s16 D_801B001C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80185228);\n    u16 *pB = (*(u16 * *)&D_80185224);\n    u16 *pC = (*(u16 * *)&D_80185230);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B0020 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B001C != 0) {\n            D_801B0020 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:30", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801823EC;\n    extern u8 D_801823E8;\n    extern u8 D_801823F4;\n    extern u16 D_801B8B78;\n    extern s16 D_801B8B74;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801823EC);\n    u16 *pB = (*(u16 * *)&D_801823E8);\n    u16 *pC = (*(u16 * *)&D_801823F4);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B8B78 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B8B74 != 0) {\n            D_801B8B78 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801823EC;\n    extern u8 D_801823E8;\n    extern u8 D_801823F4;\n    extern u16 D_801B8B78;\n    extern s16 D_801B8B74;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801823EC);\n    u16 *pB = (*(u16 * *)&D_801823E8);\n    u16 *pC = (*(u16 * *)&D_801823F4);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801B8B78 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801B8B74 != 0) {\n            D_801B8B78 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:31", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80191DC8;\n    extern u8 D_80191DC4;\n    extern u8 D_80191DD0;\n    extern u16 D_801CF2E8;\n    extern s16 D_801CF2E4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80191DC8);\n    u16 *pB = (*(u16 * *)&D_80191DC4);\n    u16 *pC = (*(u16 * *)&D_80191DD0);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CF2E8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CF2E4 != 0) {\n            D_801CF2E8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80191DC8;\n    extern u8 D_80191DC4;\n    extern u8 D_80191DD0;\n    extern u16 D_801CF2E8;\n    extern s16 D_801CF2E4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80191DC8);\n    u16 *pB = (*(u16 * *)&D_80191DC4);\n    u16 *pC = (*(u16 * *)&D_80191DD0);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CF2E8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CF2E4 != 0) {\n            D_801CF2E8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:31", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018CAFC;\n    extern u8 D_8018CAF8;\n    extern u8 D_8018CB04;\n    extern u16 D_801DB918;\n    extern s16 D_801DB914;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018CAFC);\n    u16 *pB = (*(u16 * *)&D_8018CAF8);\n    u16 *pC = (*(u16 * *)&D_8018CB04);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801DB918 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801DB914 != 0) {\n            D_801DB918 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018CAFC;\n    extern u8 D_8018CAF8;\n    extern u8 D_8018CB04;\n    extern u16 D_801DB918;\n    extern s16 D_801DB914;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018CAFC);\n    u16 *pB = (*(u16 * *)&D_8018CAF8);\n    u16 *pC = (*(u16 * *)&D_8018CB04);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801DB918 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801DB914 != 0) {\n            D_801DB918 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:31", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E568;\n    extern u8 D_8017E564;\n    extern u8 D_8017E570;\n    extern u16 D_8019BFF8;\n    extern s16 D_8019BFF4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E568);\n    u16 *pB = (*(u16 * *)&D_8017E564);\n    u16 *pC = (*(u16 * *)&D_8017E570);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019BFF8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019BFF4 != 0) {\n            D_8019BFF8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E568;\n    extern u8 D_8017E564;\n    extern u8 D_8017E570;\n    extern u16 D_8019BFF8;\n    extern s16 D_8019BFF4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E568);\n    u16 *pB = (*(u16 * *)&D_8017E564);\n    u16 *pC = (*(u16 * *)&D_8017E570);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019BFF8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019BFF4 != 0) {\n            D_8019BFF8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:32", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018FD84;\n    extern u8 D_8018FD80;\n    extern u8 D_8018FD8C;\n    extern u16 D_801DFE58;\n    extern s16 D_801DFE54;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018FD84);\n    u16 *pB = (*(u16 * *)&D_8018FD80);\n    u16 *pC = (*(u16 * *)&D_8018FD8C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801DFE58 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801DFE54 != 0) {\n            D_801DFE58 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8018FD84;\n    extern u8 D_8018FD80;\n    extern u8 D_8018FD8C;\n    extern u16 D_801DFE58;\n    extern s16 D_801DFE54;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8018FD84);\n    u16 *pB = (*(u16 * *)&D_8018FD80);\n    u16 *pC = (*(u16 * *)&D_8018FD8C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801DFE58 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801DFE54 != 0) {\n            D_801DFE58 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:32", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801938B8;\n    extern u8 D_801938B4;\n    extern u8 D_801938C0;\n    extern u16 D_801CF228;\n    extern s16 D_801CF224;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801938B8);\n    u16 *pB = (*(u16 * *)&D_801938B4);\n    u16 *pC = (*(u16 * *)&D_801938C0);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CF228 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CF224 != 0) {\n            D_801CF228 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801938B8;\n    extern u8 D_801938B4;\n    extern u8 D_801938C0;\n    extern u16 D_801CF228;\n    extern s16 D_801CF224;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801938B8);\n    u16 *pB = (*(u16 * *)&D_801938B4);\n    u16 *pC = (*(u16 * *)&D_801938C0);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CF228 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CF224 != 0) {\n            D_801CF228 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:32", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182C10;\n    extern u8 D_80182C0C;\n    extern u8 D_80182C18;\n    extern u16 D_801CE830;\n    extern s16 D_801CE82C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182C10);\n    u16 *pB = (*(u16 * *)&D_80182C0C);\n    u16 *pC = (*(u16 * *)&D_80182C18);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CE830 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CE82C != 0) {\n            D_801CE830 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182C10;\n    extern u8 D_80182C0C;\n    extern u8 D_80182C18;\n    extern u16 D_801CE830;\n    extern s16 D_801CE82C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182C10);\n    u16 *pB = (*(u16 * *)&D_80182C0C);\n    u16 *pC = (*(u16 * *)&D_80182C18);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801CE830 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801CE82C != 0) {\n            D_801CE830 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:33", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.25, "objects": ["build/src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80181AC0;\n    extern u8 D_80181ABC;\n    extern u8 D_80181AC8;\n    extern u16 D_801A98E0;\n    extern s16 D_801A98DC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80181AC0);\n    u16 *pB = (*(u16 * *)&D_80181ABC);\n    u16 *pC = (*(u16 * *)&D_80181AC8);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A98E0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A98DC != 0) {\n            D_801A98E0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80181AC0;\n    extern u8 D_80181ABC;\n    extern u8 D_80181AC8;\n    extern u16 D_801A98E0;\n    extern s16 D_801A98DC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80181AC0);\n    u16 *pB = (*(u16 * *)&D_80181ABC);\n    u16 *pC = (*(u16 * *)&D_80181AC8);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A98E0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A98DC != 0) {\n            D_801A98E0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:33", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_007/ov_SC07_007_jr_80131340.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.121, "objects": ["build/src/ov_SC07_007/ov_SC07_007_jr_80131340.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801834C4;\n    extern u8 D_801834C0;\n    extern u8 D_801834CC;\n    extern u16 D_801C6540;\n    extern s16 D_801C653C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801834C4);\n    u16 *pB = (*(u16 * *)&D_801834C0);\n    u16 *pC = (*(u16 * *)&D_801834CC);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C6540 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C653C != 0) {\n            D_801C6540 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_801834C4;\n    extern u8 D_801834C0;\n    extern u8 D_801834CC;\n    extern u16 D_801C6540;\n    extern s16 D_801C653C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_801834C4);\n    u16 *pB = (*(u16 * *)&D_801834C0);\n    u16 *pC = (*(u16 * *)&D_801834CC);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801C6540 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801C653C != 0) {\n            D_801C6540 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:33", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_010/ov_SC07_010_jr_80131340.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.119, "objects": ["build/src/ov_SC07_010/ov_SC07_010_jr_80131340.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182554;\n    extern u8 D_80182550;\n    extern u8 D_8018255C;\n    extern u16 D_801A6A38;\n    extern s16 D_801A6A34;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182554);\n    u16 *pB = (*(u16 * *)&D_80182550);\n    u16 *pC = (*(u16 * *)&D_8018255C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A6A38 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A6A34 != 0) {\n            D_801A6A38 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80182554;\n    extern u8 D_80182550;\n    extern u8 D_8018255C;\n    extern u16 D_801A6A38;\n    extern s16 D_801A6A34;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80182554);\n    u16 *pB = (*(u16 * *)&D_80182550);\n    u16 *pC = (*(u16 * *)&D_8018255C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A6A38 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A6A34 != 0) {\n            D_801A6A38 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:33", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_011/ov_SC07_011_jr_80131340.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.118, "objects": ["build/src/ov_SC07_011/ov_SC07_011_jr_80131340.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017EC14;\n    extern u8 D_8017EC10;\n    extern u8 D_8017EC1C;\n    extern u16 D_8018F0D0;\n    extern s16 D_8018F0CC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017EC14);\n    u16 *pB = (*(u16 * *)&D_8017EC10);\n    u16 *pC = (*(u16 * *)&D_8017EC1C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018F0D0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018F0CC != 0) {\n            D_8018F0D0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017EC14;\n    extern u8 D_8017EC10;\n    extern u8 D_8017EC1C;\n    extern u16 D_8018F0D0;\n    extern s16 D_8018F0CC;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017EC14);\n    u16 *pB = (*(u16 * *)&D_8017EC10);\n    u16 *pC = (*(u16 * *)&D_8017EC1C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018F0D0 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018F0CC != 0) {\n            D_8018F0D0 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:33", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017D894;\n    extern u8 D_8017D890;\n    extern u8 D_8017D89C;\n    extern u16 D_80195318;\n    extern s16 D_80195314;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017D894);\n    u16 *pB = (*(u16 * *)&D_8017D890);\n    u16 *pC = (*(u16 * *)&D_8017D89C);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80195318 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80195314 != 0) {\n            D_80195318 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017D894;\n    extern u8 D_8017D890;\n    extern u8 D_8017D89C;\n    extern u16 D_80195318;\n    extern s16 D_80195314;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017D894);\n    u16 *pB = (*(u16 * *)&D_8017D890);\n    u16 *pC = (*(u16 * *)&D_8017D89C);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_80195318 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_80195314 != 0) {\n            D_80195318 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:34", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.248, "objects": ["build/src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E338;\n    extern u8 D_8017E334;\n    extern u8 D_8017E340;\n    extern u16 D_801A29A8;\n    extern s16 D_801A29A4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E338);\n    u16 *pB = (*(u16 * *)&D_8017E334);\n    u16 *pC = (*(u16 * *)&D_8017E340);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A29A8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A29A4 != 0) {\n            D_801A29A8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017E338;\n    extern u8 D_8017E334;\n    extern u8 D_8017E340;\n    extern u16 D_801A29A8;\n    extern s16 D_801A29A4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017E338);\n    u16 *pB = (*(u16 * *)&D_8017E334);\n    u16 *pC = (*(u16 * *)&D_8017E340);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_801A29A8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_801A29A4 != 0) {\n            D_801A29A8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:34", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.c", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": false, "includers": 0, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186D7C;\n    extern u8 D_80186D78;\n    extern u8 D_80186D84;\n    extern u16 D_8019A430;\n    extern s16 D_8019A42C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186D7C);\n    u16 *pB = (*(u16 * *)&D_80186D78);\n    u16 *pC = (*(u16 * *)&D_80186D84);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019A430 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019A42C != 0) {\n            D_8019A430 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_80186D7C;\n    extern u8 D_80186D78;\n    extern u8 D_80186D84;\n    extern u16 D_8019A430;\n    extern s16 D_8019A42C;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_80186D7C);\n    u16 *pB = (*(u16 * *)&D_80186D78);\n    u16 *pC = (*(u16 * *)&D_80186D84);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8019A430 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8019A42C != 0) {\n            D_8019A430 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:31:35", "label": "c4p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/shared/ov/func_80133AB0__49df14d8.h", "fn": "func_80133AB0", "addr": 2148743856, "aliases": null, "header": true, "includers": 3, "nhash_before": "83019db5fa04c31982b6c9e3bb3913ff71218ec3", "nhash_after": "e52fe6d660617468c6358f043f05169a46f838f2", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80133AB0", "verdict": "LEVER-FREE", "sites": [], "compiles": 3, "seconds": 0.743, "objects": ["build/src/ov_SC03_126/ov_SC03_126_jr_8012ACE0.o", "build/src/ov_SC04_021/ov_SC04_021_jr_8012ACE0.o", "build/src/ov_SC05_019/ov_SC05_019_jr_8012ACE0.o"], "before_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F80C;\n    extern u8 D_8017F808;\n    extern u8 D_8017F814;\n    extern u16 D_8018E6F8;\n    extern s16 D_8018E6F4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F80C);\n    u16 *pB = (*(u16 * *)&D_8017F808);\n    u16 *pC = (*(u16 * *)&D_8017F814);\n    register int zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B headers1)\n    u32 X, Y, cell, Xc, Yc;\n    u16 k, off;\n    int cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    register int harg __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B headers1)\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Xc) : \"r\"(X));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B headers1)\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    __asm__(\"addu %0,%1,$zero\" : \"=r\"(Yc) : \"r\"(Y));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B headers1)\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (((cnt-- + zr) & 0xffff) != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib + zr;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018E6F8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018E6F4 != 0) {\n            D_8018E6F8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n", "after_text": "s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)\n{\n    extern u8 D_8017F80C;\n    extern u8 D_8017F808;\n    extern u8 D_8017F814;\n    extern u16 D_8018E6F8;\n    extern s16 D_8018E6F4;\n    extern s32 func_80133CD4();\n\n    Map_80133AB0 *map = (Map_80133AB0 *)arg3;\n    u16 *pA = (*(u16 * *)&D_8017F80C);\n    u16 *pB = (*(u16 * *)&D_8017F808);\n    u16 *pC = (*(u16 * *)&D_8017F814);\n    u32 X, Y, cell;\n    u16 Xc, Yc;\n    u16 k, off;\n    u16 cnt;\n    u16 *cp, *lst;\n    u8 *s0;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    s32 ret;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n    u16 *cells;\n\n    pC[0] = pA[0] - pB[0];\n    pC[1] = pA[1] - pB[1];\n    pC[2] = pA[2] - pB[2];\n\n    X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if (!((X & 0xffff) < map->w))\n        return 0;\n    Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if (!((Y & 0xffff) < map->h))\n        return 0;\n\n    cell = Yc * map->w + Xc;\n    cells = map->cells;\n    p14 = map->p14;\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = cell * 2;\n    cp = (u16 *)(k * 2 + (u32)cells);\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off);\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n        }\n        ret = (s16)func_80133CD4((s16)(harg | flag), s0, p10, p0C);\n        if (ret != 0) {\n            if (ret > 0)\n                D_8018E6F8 = *(u16 *)s0;\n            return 1;\n        }\n        lst++;\n        if (D_8018E6F4 != 0) {\n            D_8018E6F8 = *(u16 *)s0;\n            return 0;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:35:18", "label": "c6", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "T7 agent c6", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8019083C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8019089C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801908A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801908C4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8019080C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8019083C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8019089C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801908A4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801908C4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8019080C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:20", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_077/ov_SC01_077_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC01_077/ov_SC01_077_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186F2C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80186F8C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186F94; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186FB4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80186EFC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80186F2C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80186F8C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186F94 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186FB4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80186EFC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:20", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FBA0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017FC00;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FC08; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FC28; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017FB70;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017FBA0 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017FC00;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017FC08 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017FC28 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017FB70;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:20", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA08; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017EA68;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA70; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA90; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017E9D8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017EA08 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017EA68;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EA70 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EA90 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017E9D8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:21", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.248, "objects": ["build/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F018; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017F078;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F080; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F0A0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017EFE8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017F018 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017F078;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F080 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F0A0 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017EFE8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:21", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.252, "objects": ["build/src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182D88; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80182DE8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182DF0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182E10; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80182D58;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80182D88 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80182DE8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182DF0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182E10 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80182D58;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:21", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183C68; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80183CC8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183CD0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183CF0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80183C38;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80183C68 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80183CC8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80183CD0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80183CF0 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80183C38;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:22", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80190CF0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80190D50;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80190D58; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80190D78; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80190CC0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80190CF0 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80190D50;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80190D58 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80190D78 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80190CC0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:22", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E0EC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017E14C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E154; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E174; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017E0BC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017E0EC + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017E14C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E154 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E174 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017E0BC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:22", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183968; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801839C8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801839D0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801839F0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80183938;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80183968 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801839C8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801839D0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801839F0 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80183938;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:23", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F62C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017F68C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F694; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F6B4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017F5FC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017F62C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017F68C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F694 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F6B4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017F5FC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:23", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186C5C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80186CBC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186CC4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186CE4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80186C2C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80186C5C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80186CBC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186CC4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186CE4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80186C2C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:23", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80191140; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801911A0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801911A8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801911C8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80191110;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80191140 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801911A0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801911A8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801911C8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80191110;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:24", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.484, "objects": ["build/src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.o", "build/src/ov_SC01_006/ov_SC01_006_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801827C0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80182820;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182828; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182848; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80182790;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801827C0 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80182820;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182828 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182848 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80182790;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:24", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E654; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017E6B4;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E6BC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E6DC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017E624;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017E654 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017E6B4;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E6BC + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E6DC + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017E624;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:25", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.48, "objects": ["build/src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.o", "build/src/ov_SC02_003/ov_SC02_003_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B00C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018B06C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B074; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B094; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018AFDC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018B00C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018B06C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018B074 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018B094 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018AFDC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:25", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A8E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018A944;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A94C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A96C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018A8B4;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018A8E4 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018A944;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018A94C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018A96C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018A8B4;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:25", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FED8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017FF38;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FF40; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FF60; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017FEA8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017FED8 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017FF38;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017FF40 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017FF60 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017FEA8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:26", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185080; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801850E0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801850E8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185108; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80185050;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80185080 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801850E0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801850E8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185108 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80185050;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:26", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B854; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018B8B4;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B8BC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B8DC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018B824;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018B854 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018B8B4;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018B8BC + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018B8DC + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018B824;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:26", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018488C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801848EC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801848F4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184914; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018485C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018488C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801848EC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801848F4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80184914 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018485C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:27", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B650; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018B6B0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B6B8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B6D8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018B620;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018B650 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018B6B0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018B6B8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018B6D8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018B620;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:27", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018652C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018658C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186594; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801865B4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801864FC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018652C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018658C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186594 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801865B4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801864FC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:27", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801848E0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80184940;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184948; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184968; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801848B0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801848E0 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80184940;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80184948 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80184968 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801848B0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:28", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F50C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017F56C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F574; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F594; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017F4DC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017F50C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017F56C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F574 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F594 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017F4DC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:28", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018590C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018596C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185974; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185994; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801858DC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018590C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018596C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185974 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185994 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801858DC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:28", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801851DC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018523C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185244; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185264; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801851AC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801851DC + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018523C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185244 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185264 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801851AC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:29", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D91C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018D97C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D984; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D9A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018D8EC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018D91C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018D97C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018D984 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018D9A4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018D8EC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:29", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F6D4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017F734;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F73C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F75C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017F6A4;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017F6D4 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017F734;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F73C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F75C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017F6A4;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:29", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018C9F0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018CA50;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018CA58; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018CA78; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018C9C0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018C9F0 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018CA50;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018CA58 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018CA78 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018C9C0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:30", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801877E8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80187848;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187850; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187870; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801877B8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801877E8 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80187848;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80187850 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80187870 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801877B8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:30", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181678; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801816D8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801816E0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181700; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80181648;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80181678 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801816D8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801816E0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80181700 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80181648;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:30", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180308; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80180368;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180370; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180390; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801802D8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80180308 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80180368;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80180370 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80180390 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801802D8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:31", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181340; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801813A0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801813A8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801813C8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80181310;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80181340 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801813A0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801813A8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801813C8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80181310;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:31", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E558; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017E5B8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E5C0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E5E0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017E528;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017E558 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017E5B8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E5C0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E5E0 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017E528;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:31", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018731C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018737C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187384; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801873A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801872EC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018731C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018737C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80187384 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801873A4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801872EC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:31", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F2F8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017F358;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F360; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F380; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017F2C8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017F2F8 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017F358;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F360 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F380 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017F2C8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:32", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BDE8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018BE48;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BE50; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BE70; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018BDB8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018BDE8 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018BE48;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018BE50 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018BE70 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018BDB8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:32", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187C20; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80187C80;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187C88; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187CA8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80187BF0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80187C20 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80187C80;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80187C88 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80187CA8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80187BF0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:33", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.471, "objects": ["build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o", "build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B97C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018B9DC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B9E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BA04; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018B94C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018B97C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018B9DC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018B9E4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018BA04 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018B94C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:33", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80189A74; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80189AD4;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80189ADC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80189AFC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80189A44;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80189A74 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80189AD4;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80189ADC + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80189AFC + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80189A44;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:33", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018CD40; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018CDA0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018CDA8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018CDC8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018CD10;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018CD40 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018CDA0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018CDA8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018CDC8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018CD10;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:34", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182778; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801827D8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801827E0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182800; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80182748;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80182778 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801827D8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801827E0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182800 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80182748;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:34", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BE98; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018BEF8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BF00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BF20; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018BE68;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018BE98 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018BEF8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018BF00 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018BF20 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018BE68;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:34", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018225C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801822BC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801822C4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801822E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018222C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018225C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801822BC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801822C4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801822E4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018222C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:35", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801862E8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80186348;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186350; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186370; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801862B8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801862E8 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80186348;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186350 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186370 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801862B8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:35", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185110; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80185170;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185178; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185198; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801850E0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80185110 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80185170;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185178 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185198 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801850E0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:35", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181344; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801813A4;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801813AC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801813CC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80181314;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80181344 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801813A4;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801813AC + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801813CC + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80181314;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:36", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187CE4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80187D44;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187D4C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187D6C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80187CB4;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80187CE4 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80187D44;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80187D4C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80187D6C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80187CB4;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:36", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180EC4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80180F24;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180F2C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180F4C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80180E94;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80180EC4 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80180F24;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80180F2C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80180F4C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80180E94;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:36", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801862A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80186304;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018630C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018632C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80186274;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801862A4 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80186304;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018630C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018632C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80186274;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:37", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184CFC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80184D5C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184D64; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184D84; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80184CCC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80184CFC + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80184D5C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80184D64 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80184D84 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80184CCC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:37", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183830; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80183890;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183898; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801838B8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80183800;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80183830 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80183890;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80183898 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801838B8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80183800;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:37", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185730; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80185790;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185798; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801857B8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80185700;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80185730 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80185790;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185798 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801857B8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80185700;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:38", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184540; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801845A0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801845A8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801845C8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80184510;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80184540 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801845A0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801845A8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801845C8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80184510;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:38", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183CD8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80183D38;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183D40; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183D60; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80183CA8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80183CD8 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80183D38;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80183D40 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80183D60 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80183CA8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:38", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186590; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801865F0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801865F8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186618; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80186560;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80186590 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801865F0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801865F8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186618 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80186560;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:38", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A758; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018A7B8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A7C0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A7E0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018A728;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018A758 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018A7B8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018A7C0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018A7E0 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018A728;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:39", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.248, "objects": ["build/src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B0D0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018B130;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B138; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B158; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018B0A0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018B0D0 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018B130;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018B138 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018B158 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018B0A0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:39", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E75C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017E7BC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E7C4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E7E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017E72C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017E75C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017E7BC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E7C4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E7E4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017E72C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:39", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801810B0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80181110;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181118; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181138; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80181080;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801810B0 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80181110;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80181118 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80181138 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80181080;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:40", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018217C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801821DC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801821E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182204; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018214C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018217C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801821DC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801821E4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182204 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018214C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:40", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184D30; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80184D90;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184D98; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184DB8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80184D00;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80184D30 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80184D90;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80184D98 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80184DB8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80184D00;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:40", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.252, "objects": ["build/src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185B38; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80185B98;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185BA0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185BC0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80185B08;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80185B38 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80185B98;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185BA0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185BC0 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80185B08;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:41", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184CCC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80184D2C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184D34; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184D54; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80184C9C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80184CCC + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80184D2C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80184D34 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80184D54 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80184C9C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:41", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EE50; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017EEB0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EEB8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EED8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017EE20;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017EE50 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017EEB0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EEB8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EED8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017EE20;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:41", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801808BC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018091C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180924; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180944; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018088C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801808BC + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018091C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80180924 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80180944 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018088C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:42", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.253, "objects": ["build/src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801831E8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80183248;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183250; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183270; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801831B8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801831E8 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80183248;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80183250 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80183270 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801831B8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:42", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182CC0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80182D20;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182D28; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182D48; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80182C90;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80182CC0 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80182D20;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182D28 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182D48 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80182C90;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:42", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182594; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801825F4;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801825FC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018261C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80182564;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80182594 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801825F4;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801825FC + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018261C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80182564;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:43", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018AFC0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018B020;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B028; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B048; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018AF90;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018AFC0 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018B020;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018B028 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018B048 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018AF90;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:43", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183694; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801836F4;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801836FC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018371C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80183664;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80183694 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801836F4;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801836FC + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018371C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80183664;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:43", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184190; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801841F0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801841F8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184218; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80184160;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80184190 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801841F0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801841F8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80184218 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80184160;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:44", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.477, "objects": ["build/src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.o", "build/src/ov_SC03_119/ov_SC03_119_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80189D78; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80189DD8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80189DE0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80189E00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80189D48;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80189D78 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80189DD8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80189DE0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80189E00 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80189D48;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:44", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188800; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80188860;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188868; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188888; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801887D0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80188800 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80188860;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80188868 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80188888 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801887D0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:45", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FFE4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80180044;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018004C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018006C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017FFB4;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017FFE4 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80180044;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018004C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018006C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017FFB4;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:45", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184AD0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80184B30;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184B38; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184B58; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80184AA0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80184AD0 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80184B30;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80184B38 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80184B58 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80184AA0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:45", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.249, "objects": ["build/src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017EF60;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF68; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF88; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017EED0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017EF00 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017EF60;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EF68 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EF88 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017EED0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:46", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018259C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801825FC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182604; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182624; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018256C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018259C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801825FC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182604 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182624 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018256C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:46", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E5AC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017E60C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E614; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E634; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017E57C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017E5AC + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017E60C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E614 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E634 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017E57C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:46", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185F9C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80185FFC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186004; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186024; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80185F6C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80185F9C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80185FFC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186004 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186024 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80185F6C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:47", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187F04; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80187F64;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187F6C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187F8C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80187ED4;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80187F04 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80187F64;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80187F6C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80187F8C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80187ED4;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:47", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA10; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017EA70;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA78; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA98; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017E9E0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017EA10 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017EA70;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EA78 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EA98 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017E9E0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:47", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018040C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018046C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180474; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180494; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801803DC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018040C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018046C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80180474 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80180494 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801803DC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:48", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184948; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801849A8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801849B0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801849D0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80184918;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80184948 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801849A8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801849B0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801849D0 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80184918;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:48", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E69C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017E6FC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E704; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E724; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017E66C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017E69C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017E6FC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E704 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E724 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017E66C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:48", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018375C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801837BC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801837C4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801837E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018372C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018375C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801837BC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801837C4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801837E4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018372C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:49", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182970; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801829D0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801829D8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801829F8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80182940;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80182970 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801829D0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801829D8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801829F8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80182940;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:49", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181A7C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80181ADC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181AE4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181B04; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80181A4C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80181A7C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80181ADC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80181AE4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80181B04 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80181A4C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:49", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.248, "objects": ["build/src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185E78; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80185ED8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185EE0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185F00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80185E48;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80185E78 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80185ED8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185EE0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185F00 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80185E48;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:50", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.249, "objects": ["build/src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182850; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801828B0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801828B8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801828D8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80182820;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80182850 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801828B0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801828B8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801828D8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80182820;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:50", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F870; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017F8D0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F8D8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F8F8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017F840;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017F870 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017F8D0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F8D8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F8F8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017F840;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:50", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180638; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80180698;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801806A0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801806C0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80180608;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80180638 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80180698;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801806A0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801806C0 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80180608;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:51", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180E6C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80180ECC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180ED4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180EF4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80180E3C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80180E6C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80180ECC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80180ED4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80180EF4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80180E3C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:51", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.474, "objects": ["build/src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.o", "build/src/ov_SC04_019/ov_SC04_019_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D624; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018D684;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D68C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D6AC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018D5F4;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018D624 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018D684;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018D68C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018D6AC + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018D5F4;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:51", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182DC4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80182E24;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182E2C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182E4C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80182D94;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80182DC4 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80182E24;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182E2C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182E4C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80182D94;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:52", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188DB0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80188E10;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188E18; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188E38; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80188D80;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80188DB0 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80188E10;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80188E18 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80188E38 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80188D80;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:52", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801939E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80193A44;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80193A4C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80193A6C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801939B4;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801939E4 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80193A44;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80193A4C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80193A6C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801939B4;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:52", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E128; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017E188;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E190; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E1B0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017E0F8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017E128 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017E188;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E190 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E1B0 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017E0F8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:53", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801821BC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018221C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182224; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182244; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018218C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801821BC + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018221C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182224 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182244 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018218C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:53", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D5E8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018D648;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D650; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D670; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018D5B8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018D5E8 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018D648;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018D650 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018D670 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018D5B8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:53", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186D44; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80186DA4;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186DAC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186DCC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80186D14;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80186D44 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80186DA4;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186DAC + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186DCC + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80186D14;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:54", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185C24; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80185C84;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185C8C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185CAC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80185BF4;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80185C24 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80185C84;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185C8C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185CAC + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80185BF4;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:54", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EFDC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017F03C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F044; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F064; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017EFAC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017EFDC + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017F03C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F044 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F064 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017EFAC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:54", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180860; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801808C0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801808C8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801808E8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80180830;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80180860 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801808C0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801808C8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801808E8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80180830;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:55", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188698; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801886F8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188700; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188720; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80188668;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80188698 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801886F8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80188700 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80188720 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80188668;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:55", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.257, "objects": ["build/src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186E00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80186E60;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186E68; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186E88; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80186DD0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80186E00 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80186E60;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186E68 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186E88 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80186DD0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:55", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180340; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801803A0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801803A8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801803C8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80180310;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80180340 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801803A0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801803A8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801803C8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80180310;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:56", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.248, "objects": ["build/src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EE98; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017EEF8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF20; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017EE68;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017EE98 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017EEF8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EF00 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EF20 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017EE68;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:56", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801852A8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80185308;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185310; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185330; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80185278;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801852A8 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80185308;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185310 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80185330 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80185278;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:56", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.252, "objects": ["build/src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D728; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018D788;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D790; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D7B0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018D6F8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018D728 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018D788;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018D790 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018D7B0 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018D6F8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:57", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018546C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801854CC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801854D4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801854F4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018543C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018546C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801854CC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801854D4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801854F4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018543C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:57", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801850A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80185104;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018510C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018512C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80185074;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801850A4 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80185104;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018510C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018512C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80185074;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:57", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182268; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801822C8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801822D0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801822F0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80182238;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80182268 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801822C8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801822D0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801822F0 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80182238;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:58", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80191C44; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80191CA4;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80191CAC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80191CCC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80191C14;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80191C44 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80191CA4;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80191CAC + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80191CCC + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80191C14;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:58", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018C978; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018C9D8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018C9E0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018CA00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018C948;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018C978 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018C9D8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018C9E0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018CA00 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018C948;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:58", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E3E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017E444;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E44C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E46C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017E3B4;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017E3E4 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017E444;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E44C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E46C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017E3B4;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:59", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018FC00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018FC60;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018FC68; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018FC88; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018FBD0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018FC00 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018FC60;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018FC68 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018FC88 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018FBD0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:59", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.253, "objects": ["build/src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80193734; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80193794;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8019379C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801937BC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80193704;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80193734 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80193794;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8019379C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801937BC + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80193704;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:35:59", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182A8C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80182AEC;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182AF4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182B14; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80182A5C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80182A8C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80182AEC;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182AF4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182B14 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80182A5C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:36:00", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018193C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018199C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801819A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801819C4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018190C;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018193C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018199C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801819A4 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801819C4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018190C;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:36:00", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017D710; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017D770;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017D778; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017D798; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017D6E0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017D710 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017D770;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017D778 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017D798 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017D6E0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:36:00", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E1B4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017E214;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E21C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E23C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017E184;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017E1B4 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017E214;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E21C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017E23C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017E184;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:36:01", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186BF8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80186C58;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186C60; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186C80; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80186BC8;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80186BF8 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80186C58;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186C60 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80186C80 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80186BC8;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:36:01", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_006/ov_SC07_006.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.204, "objects": ["build/src/ov_SC07_006/ov_SC07_006.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A81C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8018A87C;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A884; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A8A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8018A7EC;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8018A81C + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8018A87C;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018A884 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8018A8A4 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8018A7EC;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:36:01", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_011/ov_SC07_011.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.203, "objects": ["build/src/ov_SC07_011/ov_SC07_011.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA90; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017EAF0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EAF8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EB18; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017EA60;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017EA90 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017EAF0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EAF8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EB18 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017EA60;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:36:02", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_010/ov_SC07_010.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.206, "objects": ["build/src/ov_SC07_010/ov_SC07_010.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801823D0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_80182430;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182438; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182458; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_801823A0;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_801823D0 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_80182430;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182438 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_80182458 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_801823A0;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:36:02", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_007/ov_SC07_007.c", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": false, "includers": 0, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.21, "objects": ["build/src/ov_SC07_007/ov_SC07_007.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183340; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_801833A0;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801833A8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801833C8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_80183310;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_80183340 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_801833A0;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801833A8 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_801833C8 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_80183310;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:36:03", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/shared/ov/func_80130D48__f3dfe4ca.h", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": true, "includers": 3, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 3, "seconds": 0.735, "objects": ["build/src/ov_SC03_126/ov_SC03_126_jr_8012ACE0.o", "build/src/ov_SC04_021/ov_SC04_021_jr_8012ACE0.o", "build/src/ov_SC05_019/ov_SC05_019_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A headers1)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F688; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A headers1)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017F6E8;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F6F0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A headers1)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F710; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A headers1)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017F658;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017F688 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017F6E8;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F6F0 + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017F710 + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017F658;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:36:03", "label": "c6p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/shared/ov/func_80130D48__bbfb4341.h", "fn": "func_80130D48", "addr": 2148732232, "aliases": null, "header": true, "includers": 2, "nhash_before": "fce331acd8a3cc4302d9a8b30126ba42728edf45", "nhash_after": "6c5a147d0742312b377f4916e5f1c43796856146", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80130D48", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.48, "objects": ["build/src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.o", "build/src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.o"], "before_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    s32 pa = arg0;\n    register u8 *p  __asm__(\"$19\") = D_80078E78;  // !FAKE: pin $19 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n    s32 s1v;\n    s32 call_a0;\n    s32 call_a1;\n    s32 cnt;\n    s32 r;\n    void *ret;\n\n    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);\n    if (s1v == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    }\n\n    switch (s1v & 0xFFFF0000) {\n    case 0x10000: {\n        u32 x = D_80078EB4;\n        u32 y = D_80078EB2;\n        u32 b;\n        u32 a;\n\n        s1v = 0;\n        if (x == y) {\n            s1v = 0xC;\n        } else if ((y >> 1) >= x) {\n            s1v = 3;\n        }\n\n        b = *(u16 *)(p + 0x40);\n        a = *(u16 *)(p + 0x3E);\n        if (b == a) {\n            s1v += 0x18;\n        } else if ((a >> 1) >= b) {\n            s1v += 6;\n        }\n        { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EED4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n\n        r = rand() % 100;\n        cnt = 0;\n    loop27:\n        if (r >= *tbl) {\n            cnt += 1;\n            tbl += 1;\n            if (cnt < 3) {\n                goto loop27;\n            }\n        }\n\n        s1v = 0;\n        switch (cnt) {\n        case 0:\n            tbl = D_8017EF34;\n            s1v = 0x31;\n            break;\n        case 1: {\n            s32 mx = *(u16 *)(p + 0x3A);\n            s32 cur = *(u16 *)(p + 0x3C);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF3C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n            s1v = 0x32;\n            break;\n        }\n        case 2: {\n            s32 mx = *(u16 *)(p + 0x3E);\n            s32 cur = *(u16 *)(p + 0x40);\n            if (((mx * 7) / 10) >= cur) {\n                s1v = 4;\n                if ((mx / 2) >= cur) {\n                    s1v = 8;\n                    if ((mx / 5) >= cur) {\n                        s1v = 0xC;\n                    }\n                }\n            }\n            { register s32 v1 __asm__(\"$3\"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF5C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n            s1v = 0x33;\n            break;\n        }\n        }\n\n        r = rand() % 100;\n        call_a1 = 0;\n    loop50:\n        if (r >= *tbl) {\n            call_a1 += 1;\n            tbl += 1;\n            if (call_a1 < 4) {\n                goto loop50;\n            }\n        }\n        call_a0 = s1v;\n        goto do_call;\n    }\n    case 0x20000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x30000:\n        call_a0 = 0x31;\n        call_a1 = 0;\n        goto do_call;\n    case 0x40000:\n        call_a0 = 0x32;\n        call_a1 = 0;\n        goto do_call;\n    case 0x50000:\n        call_a0 = 0x33;\n        call_a1 = 0;\n        goto do_call;\n    case 0x60000: {\n        s32 rr = rand() & 0xFF;\n        tbl = D_8017EEA4;\n        if (rr >= *tbl) {\n            do {\n                tbl += 3;\n            } while (rr >= *tbl);\n        }\n        call_a0 = tbl[1];\n        if (*(u16 *)(p + 0x40) < 4U) {\n            call_a0 = 0x33;\n        }\n        call_a1 = tbl[2];\n        goto do_call;\n    }\n    case 0x70000:\n        call_a0 = 0x27B;\n        call_a1 = 0;\n        goto do_call;\n    default:\n        return;\n    }\n\ndo_call:\n    ret = func_8012C658(call_a0, call_a1, pa);\n    if (ret != 0) {\n        *(u16 *)((s8 *)ret + 0xA) -= 0x20;\n    }\n}\n", "after_text": "void func_80130D48(s32 arg0)\n{\n    s16 *tbl;\n    u8 *p = D_80078E78;\n    s32 val;\n    s32 i;\n    s32 j;\n    s32 r;\n    s32 ret;\n\n    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);\n    if (val == 0) {\n        return;\n    }\n\n    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {\n        ret = func_8012C658(0x33, 0, arg0);\n    } else {\n        switch (val & 0xFFFF0000) {\n        case 0x10000: {\n            u32 x = D_80078EB4;\n            u32 y = D_80078EB2;\n            u32 b;\n            u32 a;\n\n            val = 0;\n            if (x == y) {\n                val = 0xC;\n            } else if ((y >> 1) >= x) {\n                val = 3;\n            }\n\n            b = *(u16 *)(p + 0x40);\n            a = *(u16 *)(p + 0x3E);\n            if (b == a) {\n                val += 0x18;\n            } else if ((a >> 1) >= b) {\n                val += 6;\n            }\n            tbl = D_8017EED4 + val;\n\n            r = rand() % 100;\n            for (i = 0; i < 3; i++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n\n            val = 0;\n            switch (i) {\n            case 0:\n                tbl = D_8017EF34;\n                val = 0x31;\n                break;\n            case 1: {\n                s32 mx = *(u16 *)(p + 0x3A);\n                s32 cur = *(u16 *)(p + 0x3C);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EF3C + val;\n                val = 0x32;\n                break;\n            }\n            case 2: {\n                s32 mx = *(u16 *)(p + 0x3E);\n                s32 cur = *(u16 *)(p + 0x40);\n                if (((mx * 7) / 10) >= cur) {\n                    val = 4;\n                    if ((mx / 2) >= cur) {\n                        val = 8;\n                        if ((mx / 5) >= cur) {\n                            val = 0xC;\n                        }\n                    }\n                }\n                tbl = D_8017EF5C + val;\n                val = 0x33;\n                break;\n            }\n            }\n\n            r = rand() % 100;\n            for (j = 0; j < 4; j++, tbl++) {\n                if (r < *tbl) {\n                    break;\n                }\n            }\n            ret = func_8012C658(val, j, arg0);\n            break;\n        }\n        case 0x20000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x30000:\n            ret = func_8012C658(0x31, 0, arg0);\n            break;\n        case 0x40000:\n            ret = func_8012C658(0x32, 0, arg0);\n            break;\n        case 0x50000:\n            ret = func_8012C658(0x33, 0, arg0);\n            break;\n        case 0x60000: {\n            s32 rr = rand() & 0xFF;\n            s32 id;\n            tbl = D_8017EEA4;\n            while (rr >= *tbl) {\n                tbl += 3;\n            }\n            id = tbl[1];\n            if (*(u16 *)(p + 0x40) < 4U) {\n                id = 0x33;\n            }\n            ret = func_8012C658(id, tbl[2], arg0);\n            break;\n        }\n        case 0x70000:\n            ret = func_8012C658(0x27B, 0, arg0);\n            break;\n        default:\n            return;\n        }\n    }\n\n    if (ret != 0) {\n        *(u16 *)(ret + 0xA) -= 0x20;\n    }\n}\n"}
+{"ts": "2026-09-10 14:36:04", "label": "c1", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "T7 agent c1", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801909BC;\n    extern u8 D_801909C0;\n    extern u8 D_801909C8;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801909C0);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801909BC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EDA30;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    D_801EDA40 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801909C4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801EDA40;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801909BC;\n    extern u8 D_801909C0;\n    extern u8 D_801909C8;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801909C0);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801909BC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EDA30;\n    ((H16 *)&D_801EDA40)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801909C4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801EDA40;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:06", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F198;\n    extern u8 D_8017F19C;\n    extern u8 D_8017F1A4;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F19C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017F198); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F1A4); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A4448;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801A4458 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F1A0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A4458;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F198;\n    extern u8 D_8017F19C;\n    extern u8 D_8017F1A4;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F19C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017F198); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F1A4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A4448;\n    ((H16 *)&D_801A4458)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F1A0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A4458;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:06", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F7AC;\n    extern u8 D_8017F7B0;\n    extern u8 D_8017F7B8;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F7B0);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017F7AC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F7B8); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018EE40;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_8018EE50 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F7B4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8018EE50;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F7AC;\n    extern u8 D_8017F7B0;\n    extern u8 D_8017F7B8;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F7B0);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017F7AC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F7B8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018EE40;\n    ((H16 *)&D_8018EE50)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F7B4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8018EE50;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:06", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80183DE8;\n    extern u8 D_80183DEC;\n    extern u8 D_80183DF4;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80183DEC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80183DE8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80183DF4); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EC6D8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801EC6E8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80183DF0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801EC6E8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80183DE8;\n    extern u8 D_80183DEC;\n    extern u8 D_80183DF4;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80183DEC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80183DE8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80183DF4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EC6D8;\n    ((H16 *)&D_801EC6E8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80183DF0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801EC6E8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:07", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017FD20;\n    extern u8 D_8017FD24;\n    extern u8 D_8017FD2C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017FD24);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017FD20); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017FD2C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A2050;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801A2060 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017FD28);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A2060;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017FD20;\n    extern u8 D_8017FD24;\n    extern u8 D_8017FD2C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017FD24);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017FD20); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017FD2C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A2050;\n    ((H16 *)&D_801A2060)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017FD28);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A2060;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:07", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182F08;\n    extern u8 D_80182F0C;\n    extern u8 D_80182F14;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182F0C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80182F08); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182F14); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801F1EB0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801F1EC0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182F10);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801F1EC0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182F08;\n    extern u8 D_80182F0C;\n    extern u8 D_80182F14;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182F0C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80182F08); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182F14); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801F1EB0;\n    ((H16 *)&D_801F1EC0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182F10);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801F1EC0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:07", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017EB88;\n    extern u8 D_8017EB8C;\n    extern u8 D_8017EB94;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017EB8C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017EB88); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017EB94); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019A930;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_8019A940 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017EB90);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019A940;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017EB88;\n    extern u8 D_8017EB8C;\n    extern u8 D_8017EB94;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017EB8C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017EB88); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017EB94); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019A930;\n    ((H16 *)&D_8019A940)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017EB90);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019A940;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:08", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186DDC;\n    extern u8 D_80186DE0;\n    extern u8 D_80186DE8;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186DE0);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80186DDC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186DE8); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C6208;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801C6218 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186DE4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C6218;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186DDC;\n    extern u8 D_80186DE0;\n    extern u8 D_80186DE8;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186DE0);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80186DDC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186DE8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C6208;\n    ((H16 *)&D_801C6218)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186DE4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C6218;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:08", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80183AE8;\n    extern u8 D_80183AEC;\n    extern u8 D_80183AF4;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80183AEC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80183AE8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80183AF4); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C4760;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801C4770 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80183AF0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C4770;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80183AE8;\n    extern u8 D_80183AEC;\n    extern u8 D_80183AF4;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80183AEC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80183AE8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80183AF4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C4760;\n    ((H16 *)&D_801C4770)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80183AF0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C4770;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:08", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E26C;\n    extern u8 D_8017E270;\n    extern u8 D_8017E278;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E270);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017E26C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E278); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80194F88;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_80194F98 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E274);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80194F98;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E26C;\n    extern u8 D_8017E270;\n    extern u8 D_8017E278;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E270);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017E26C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E278); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80194F88;\n    ((H16 *)&D_80194F98)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E274);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80194F98;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:09", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.252, "objects": ["build/src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80190E70;\n    extern u8 D_80190E74;\n    extern u8 D_80190E7C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80190E74);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80190E70); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80190E7C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E3000;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801E3010 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80190E78);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E3010;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80190E70;\n    extern u8 D_80190E74;\n    extern u8 D_80190E7C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80190E74);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80190E70); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80190E7C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E3000;\n    ((H16 *)&D_801E3010)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80190E78);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E3010;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:09", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E7D4;\n    extern u8 D_8017E7D8;\n    extern u8 D_8017E7E0;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E7D8);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017E7D4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E7E0); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018F060;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_8018F070 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E7DC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8018F070;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E7D4;\n    extern u8 D_8017E7D8;\n    extern u8 D_8017E7E0;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E7D8);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017E7D4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E7E0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018F060;\n    ((H16 *)&D_8018F070)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E7DC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8018F070;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:09", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018AA64;\n    extern u8 D_8018AA68;\n    extern u8 D_8018AA70;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018AA68);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018AA64); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018AA70); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EE4A0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801EE4B0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018AA6C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801EE4B0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018AA64;\n    extern u8 D_8018AA68;\n    extern u8 D_8018AA70;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018AA68);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018AA64); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018AA70); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EE4A0;\n    ((H16 *)&D_801EE4B0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018AA6C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801EE4B0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:10", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801912C0;\n    extern u8 D_801912C4;\n    extern u8 D_801912CC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801912C4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801912C0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801912CC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E9EE0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801E9EF0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801912C8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E9EF0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801912C0;\n    extern u8 D_801912C4;\n    extern u8 D_801912CC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801912C4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801912C0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801912CC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E9EE0;\n    ((H16 *)&D_801E9EF0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801912C8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E9EF0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:10", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184A0C;\n    extern u8 D_80184A10;\n    extern u8 D_80184A18;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184A10);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80184A0C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184A18); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B2C78;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801B2C88 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184A14);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B2C88;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184A0C;\n    extern u8 D_80184A10;\n    extern u8 D_80184A18;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184A10);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80184A0C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184A18); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B2C78;\n    ((H16 *)&D_801B2C88)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184A14);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B2C88;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:11", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.483, "objects": ["build/src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.o", "build/src/ov_SC01_006/ov_SC01_006_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182940;\n    extern u8 D_80182944;\n    extern u8 D_8018294C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182944);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80182940); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018294C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CC5A0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801CC5B0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182948);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CC5B0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182940;\n    extern u8 D_80182944;\n    extern u8 D_8018294C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182944);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80182940); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018294C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CC5A0;\n    ((H16 *)&D_801CC5B0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182948);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CC5B0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:11", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80180058;\n    extern u8 D_8018005C;\n    extern u8 D_80180064;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018005C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80180058); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80180064); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80191A10;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_80191A20 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80180060);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80191A20;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80180058;\n    extern u8 D_8018005C;\n    extern u8 D_80180064;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018005C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80180058); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80180064); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80191A10;\n    ((H16 *)&D_80191A20)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80180060);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80191A20;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:11", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801866AC;\n    extern u8 D_801866B0;\n    extern u8 D_801866B8;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801866B0);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801866AC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801866B8); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CEE50;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801CEE60 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801866B4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CEE60;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801866AC;\n    extern u8 D_801866B0;\n    extern u8 D_801866B8;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801866B0);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801866AC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801866B8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CEE50;\n    ((H16 *)&D_801CEE60)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801866B4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CEE60;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:12", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.48, "objects": ["build/src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.o", "build/src/ov_SC02_003/ov_SC02_003_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018B18C;\n    extern u8 D_8018B190;\n    extern u8 D_8018B198;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018B190);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018B18C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018B198); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E6D38;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801E6D48 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018B194);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E6D48;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018B18C;\n    extern u8 D_8018B190;\n    extern u8 D_8018B198;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018B190);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018B18C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018B198); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E6D38;\n    ((H16 *)&D_801E6D48)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018B194);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E6D48;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:12", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018B7D0;\n    extern u8 D_8018B7D4;\n    extern u8 D_8018B7DC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018B7D4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018B7D0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018B7DC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D8BC0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801D8BD0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018B7D8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D8BD0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018B7D0;\n    extern u8 D_8018B7D4;\n    extern u8 D_8018B7DC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018B7D4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018B7D0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018B7DC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D8BC0;\n    ((H16 *)&D_801D8BD0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018B7D8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D8BD0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:13", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185200;\n    extern u8 D_80185204;\n    extern u8 D_8018520C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185204);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80185200); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018520C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B62D8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801B62E8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185208);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B62E8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185200;\n    extern u8 D_80185204;\n    extern u8 D_8018520C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185204);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80185200); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018520C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B62D8;\n    ((H16 *)&D_801B62E8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185208);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B62E8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:13", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018B9D4;\n    extern u8 D_8018B9D8;\n    extern u8 D_8018B9E0;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018B9D8);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018B9D4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018B9E0); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D1B60;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801D1B70 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018B9DC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D1B70;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018B9D4;\n    extern u8 D_8018B9D8;\n    extern u8 D_8018B9E0;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018B9D8);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018B9D4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018B9E0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D1B60;\n    ((H16 *)&D_801D1B70)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018B9DC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D1B70;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:13", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184A60;\n    extern u8 D_80184A64;\n    extern u8 D_80184A6C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184A64);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80184A60); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184A6C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BD608;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801BD618 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184A68);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801BD618;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184A60;\n    extern u8 D_80184A64;\n    extern u8 D_80184A6C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184A64);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80184A60); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184A6C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BD608;\n    ((H16 *)&D_801BD618)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184A68);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801BD618;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:14", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F68C;\n    extern u8 D_8017F690;\n    extern u8 D_8017F698;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F690);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017F68C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F698); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019F9B8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_8019F9C8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F694);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019F9C8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F68C;\n    extern u8 D_8017F690;\n    extern u8 D_8017F698;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F690);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017F68C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F698); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019F9B8;\n    ((H16 *)&D_8019F9C8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F694);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019F9C8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:14", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018DA9C;\n    extern u8 D_8018DAA0;\n    extern u8 D_8018DAA8;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018DAA0);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018DA9C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018DAA8); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801ED3B0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801ED3C0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018DAA4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801ED3C0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018DA9C;\n    extern u8 D_8018DAA0;\n    extern u8 D_8018DAA8;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018DAA0);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018DA9C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018DAA8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801ED3B0;\n    ((H16 *)&D_801ED3C0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018DAA4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801ED3C0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:14", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018535C;\n    extern u8 D_80185360;\n    extern u8 D_80185368;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185360);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018535C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80185368); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B7D30;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801B7D40 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185364);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B7D40;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018535C;\n    extern u8 D_80185360;\n    extern u8 D_80185368;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185360);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018535C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80185368); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B7D30;\n    ((H16 *)&D_801B7D40)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185364);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B7D40;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:15", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185A8C;\n    extern u8 D_80185A90;\n    extern u8 D_80185A98;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185A90);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80185A8C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80185A98); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CA430;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801CA440 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185A94);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CA440;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185A8C;\n    extern u8 D_80185A90;\n    extern u8 D_80185A98;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185A90);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80185A8C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80185A98); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CA430;\n    ((H16 *)&D_801CA440)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185A94);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CA440;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:15", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.247, "objects": ["build/src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F854;\n    extern u8 D_8017F858;\n    extern u8 D_8017F860;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F858);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017F854); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F860); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018E738;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_8018E748 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F85C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8018E748;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F854;\n    extern u8 D_8017F858;\n    extern u8 D_8017F860;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F858);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017F854); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F860); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018E738;\n    ((H16 *)&D_8018E748)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F85C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8018E748;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:15", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018CB70;\n    extern u8 D_8018CB74;\n    extern u8 D_8018CB7C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018CB74);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018CB70); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018CB7C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801F60B0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801F60C0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018CB78);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801F60C0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018CB70;\n    extern u8 D_8018CB74;\n    extern u8 D_8018CB7C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018CB74);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018CB70); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018CB7C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801F60B0;\n    ((H16 *)&D_801F60C0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018CB78);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801F60C0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:16", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E6D8;\n    extern u8 D_8017E6DC;\n    extern u8 D_8017E6E4;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E6DC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017E6D8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E6E4); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80193D20;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_80193D30 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E6E0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80193D30;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E6D8;\n    extern u8 D_8017E6DC;\n    extern u8 D_8017E6E4;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E6DC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017E6D8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E6E4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80193D20;\n    ((H16 *)&D_80193D30)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E6E0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80193D30;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:16", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80180488;\n    extern u8 D_8018048C;\n    extern u8 D_80180494;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018048C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80180488); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80180494); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019EC68;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_8019EC78 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80180490);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019EC78;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80180488;\n    extern u8 D_8018048C;\n    extern u8 D_80180494;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018048C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80180488); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80180494); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019EC68;\n    ((H16 *)&D_8019EC78)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80180490);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019EC78;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:16", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80187968;\n    extern u8 D_8018796C;\n    extern u8 D_80187974;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018796C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80187968); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80187974); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E8A08;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801E8A18 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80187970);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E8A18;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80187968;\n    extern u8 D_8018796C;\n    extern u8 D_80187974;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018796C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80187968); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80187974); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E8A08;\n    ((H16 *)&D_801E8A18)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80187970);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E8A18;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:17", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801814C0;\n    extern u8 D_801814C4;\n    extern u8 D_801814CC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801814C4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801814C0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801814CC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801ABFF0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801AC000 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801814C8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801AC000;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801814C0;\n    extern u8 D_801814C4;\n    extern u8 D_801814CC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801814C4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801814C0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801814CC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801ABFF0;\n    ((H16 *)&D_801AC000)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801814C8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801AC000;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:17", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801817F8;\n    extern u8 D_801817FC;\n    extern u8 D_80181804;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801817FC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801817F8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80181804); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A0F00;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801A0F10 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80181800);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A0F10;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801817F8;\n    extern u8 D_801817FC;\n    extern u8 D_80181804;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801817FC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801817F8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80181804); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A0F00;\n    ((H16 *)&D_801A0F10)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80181800);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A0F10;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:17", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F478;\n    extern u8 D_8017F47C;\n    extern u8 D_8017F484;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F47C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017F478); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F484); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80197948;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_80197958 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F480);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80197958;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F478;\n    extern u8 D_8017F47C;\n    extern u8 D_8017F484;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F47C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017F478); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F484); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80197948;\n    ((H16 *)&D_80197958)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F480);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80197958;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:17", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018BF68;\n    extern u8 D_8018BF6C;\n    extern u8 D_8018BF74;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018BF6C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018BF68); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018BF74); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EA218;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801EA228 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018BF70);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801EA228;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018BF68;\n    extern u8 D_8018BF6C;\n    extern u8 D_8018BF74;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018BF6C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018BF68); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018BF74); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EA218;\n    ((H16 *)&D_801EA228)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018BF70);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801EA228;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:18", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018749C;\n    extern u8 D_801874A0;\n    extern u8 D_801874A8;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801874A0);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018749C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801874A8); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BFEE0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801BFEF0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801874A4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801BFEF0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018749C;\n    extern u8 D_801874A0;\n    extern u8 D_801874A8;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801874A0);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018749C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801874A8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BFEE0;\n    ((H16 *)&D_801BFEF0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801874A4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801BFEF0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:18", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80187DA0;\n    extern u8 D_80187DA4;\n    extern u8 D_80187DAC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80187DA4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80187DA0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80187DAC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D81F0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801D8200 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80187DA8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D8200;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80187DA0;\n    extern u8 D_80187DA4;\n    extern u8 D_80187DAC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80187DA4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80187DA0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80187DAC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D81F0;\n    ((H16 *)&D_801D8200)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80187DA8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D8200;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:19", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.492, "objects": ["build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o", "build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018BAFC;\n    extern u8 D_8018BB00;\n    extern u8 D_8018BB08;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018BB00);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus2)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018BAFC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018BB08); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E9570;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    D_801E9580 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018BB04);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E9580;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018BAFC;\n    extern u8 D_8018BB00;\n    extern u8 D_8018BB08;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018BB00);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018BAFC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018BB08); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E9570;\n    ((H16 *)&D_801E9580)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018BB04);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E9580;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:19", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7103); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80193B64;\n    extern u8 D_80193B68;\n    extern u8 D_80193B70;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80193B68);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80193B64); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80193B70); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D3C48;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801D3C58 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80193B6C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D3C58;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80193B64;\n    extern u8 D_80193B68;\n    extern u8 D_80193B70;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80193B68);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80193B64); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80193B70); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D3C48;\n    ((H16 *)&D_801D3C58)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80193B6C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D3C58;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:19", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E2A8;\n    extern u8 D_8017E2AC;\n    extern u8 D_8017E2B4;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E2AC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017E2A8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E2B4); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019BD98;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_8019BDA8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E2B0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019BDA8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E2A8;\n    extern u8 D_8017E2AC;\n    extern u8 D_8017E2B4;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E2AC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017E2A8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E2B4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019BD98;\n    ((H16 *)&D_8019BDA8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E2B0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019BDA8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:20", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018233C;\n    extern u8 D_80182340;\n    extern u8 D_80182348;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182340);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018233C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182348); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801F6DA0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801F6DB0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182344);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801F6DB0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018233C;\n    extern u8 D_80182340;\n    extern u8 D_80182348;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182340);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018233C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182348); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801F6DA0;\n    ((H16 *)&D_801F6DB0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182344);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801F6DB0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:20", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018D768;\n    extern u8 D_8018D76C;\n    extern u8 D_8018D774;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018D76C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018D768); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018D774); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EB8D8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801EB8E8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018D770);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801EB8E8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018D768;\n    extern u8 D_8018D76C;\n    extern u8 D_8018D774;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018D76C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018D768); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018D774); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EB8D8;\n    ((H16 *)&D_801EB8E8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018D770);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801EB8E8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:20", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186EC4;\n    extern u8 D_80186EC8;\n    extern u8 D_80186ED0;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186EC8);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80186EC4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186ED0); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E5018;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801E5028 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186ECC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E5028;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186EC4;\n    extern u8 D_80186EC8;\n    extern u8 D_80186ED0;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186EC8);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80186EC4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186ED0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E5018;\n    ((H16 *)&D_801E5028)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186ECC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E5028;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:21", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185DA4;\n    extern u8 D_80185DA8;\n    extern u8 D_80185DB0;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185DA8);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80185DA4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80185DB0); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A8D20;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801A8D30 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185DAC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A8D30;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185DA4;\n    extern u8 D_80185DA8;\n    extern u8 D_80185DB0;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185DA8);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80185DA4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80185DB0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A8D20;\n    ((H16 *)&D_801A8D30)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185DAC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A8D30;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:21", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F15C;\n    extern u8 D_8017F160;\n    extern u8 D_8017F168;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F160);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017F15C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F168); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801997C0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801997D0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F164);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801997D0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F15C;\n    extern u8 D_8017F160;\n    extern u8 D_8017F168;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F160);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017F15C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F168); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801997C0;\n    ((H16 *)&D_801997D0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F164);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801997D0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:21", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801809E0;\n    extern u8 D_801809E4;\n    extern u8 D_801809EC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801809E4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801809E0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801809EC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801AA908;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801AA918 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801809E8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801AA918;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801809E0;\n    extern u8 D_801809E4;\n    extern u8 D_801809EC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801809E4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801809E0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801809EC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801AA908;\n    ((H16 *)&D_801AA918)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801809E8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801AA918;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:22", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80188818;\n    extern u8 D_8018881C;\n    extern u8 D_80188824;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018881C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80188818); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80188824); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801AD358;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801AD368 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80188820);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801AD368;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80188818;\n    extern u8 D_8018881C;\n    extern u8 D_80188824;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018881C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80188818); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80188824); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801AD358;\n    ((H16 *)&D_801AD368)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80188820);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801AD368;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:22", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186F80;\n    extern u8 D_80186F84;\n    extern u8 D_80186F8C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186F84);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80186F80); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186F8C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B0D58;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801B0D68 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186F88);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B0D68;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186F80;\n    extern u8 D_80186F84;\n    extern u8 D_80186F8C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186F84);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80186F80); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186F8C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B0D58;\n    ((H16 *)&D_801B0D68)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186F88);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B0D68;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:22", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801804C0;\n    extern u8 D_801804C4;\n    extern u8 D_801804CC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801804C4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801804C0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801804CC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A01B0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801A01C0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801804C8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A01C0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801804C0;\n    extern u8 D_801804C4;\n    extern u8 D_801804CC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801804C4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801804C0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801804CC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A01B0;\n    ((H16 *)&D_801A01C0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801804C8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A01C0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:23", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F018;\n    extern u8 D_8017F01C;\n    extern u8 D_8017F024;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F01C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017F018); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F024); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80193590;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801935A0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F020);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801935A0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F018;\n    extern u8 D_8017F01C;\n    extern u8 D_8017F024;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F01C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017F018); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F024); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80193590;\n    ((H16 *)&D_801935A0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F020);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801935A0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:23", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185428;\n    extern u8 D_8018542C;\n    extern u8 D_80185434;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018542C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80185428); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80185434); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019E360;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_8019E370 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185430);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019E370;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185428;\n    extern u8 D_8018542C;\n    extern u8 D_80185434;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018542C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80185428); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80185434); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019E360;\n    ((H16 *)&D_8019E370)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185430);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019E370;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:23", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018D8A8;\n    extern u8 D_8018D8AC;\n    extern u8 D_8018D8B4;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018D8AC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018D8A8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018D8B4); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E0CC8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801E0CD8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018D8B0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E0CD8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018D8A8;\n    extern u8 D_8018D8AC;\n    extern u8 D_8018D8B4;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018D8AC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018D8A8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018D8B4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E0CC8;\n    ((H16 *)&D_801E0CD8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018D8B0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E0CD8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:24", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801855EC;\n    extern u8 D_801855F0;\n    extern u8 D_801855F8;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801855F0);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801855EC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801855F8); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B9460;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801B9470 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801855F4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B9470;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801855EC;\n    extern u8 D_801855F0;\n    extern u8 D_801855F8;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801855F0);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801855EC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801855F8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B9460;\n    ((H16 *)&D_801B9470)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801855F4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B9470;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:24", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80189BF4;\n    extern u8 D_80189BF8;\n    extern u8 D_80189C00;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80189BF8);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80189BF4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80189C00); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C54A0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801C54B0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80189BFC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C54B0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80189BF4;\n    extern u8 D_80189BF8;\n    extern u8 D_80189C00;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80189BF8);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80189BF4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80189C00); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C54A0;\n    ((H16 *)&D_801C54B0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80189BFC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C54B0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:24", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801828F8;\n    extern u8 D_801828FC;\n    extern u8 D_80182904;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801828FC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801828F8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182904); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C4BE8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801C4BF8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182900);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C4BF8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801828F8;\n    extern u8 D_801828FC;\n    extern u8 D_80182904;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801828FC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801828F8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182904); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C4BE8;\n    ((H16 *)&D_801C4BF8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182900);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C4BF8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:25", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801823DC;\n    extern u8 D_801823E0;\n    extern u8 D_801823E8;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801823E0);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801823DC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801823E8); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E07E8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801E07F8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801823E4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E07F8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801823DC;\n    extern u8 D_801823E0;\n    extern u8 D_801823E8;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801823E0);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801823DC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801823E8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E07E8;\n    ((H16 *)&D_801E07F8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801823E4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E07F8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:25", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185290;\n    extern u8 D_80185294;\n    extern u8 D_8018529C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185294);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80185290); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018529C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B1BA0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801B1BB0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185298);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B1BB0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185290;\n    extern u8 D_80185294;\n    extern u8 D_8018529C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185294);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80185290); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018529C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B1BA0;\n    ((H16 *)&D_801B1BB0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185298);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B1BB0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:25", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018CEC0;\n    extern u8 D_8018CEC4;\n    extern u8 D_8018CECC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018CEC4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018CEC0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018CECC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D0FD8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801D0FE8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018CEC8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D0FE8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018CEC0;\n    extern u8 D_8018CEC4;\n    extern u8 D_8018CECC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018CEC4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018CEC0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018CECC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D0FD8;\n    ((H16 *)&D_801D0FE8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018CEC8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D0FE8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:26", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018C018;\n    extern u8 D_8018C01C;\n    extern u8 D_8018C024;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018C01C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018C018); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018C024); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CA908;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801CA918 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018C020);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CA918;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018C018;\n    extern u8 D_8018C01C;\n    extern u8 D_8018C024;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018C01C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018C018); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018C024); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CA908;\n    ((H16 *)&D_801CA918)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018C020);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CA918;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:26", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186468;\n    extern u8 D_8018646C;\n    extern u8 D_80186474;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018646C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80186468); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186474); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CB010;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801CB020 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186470);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CB020;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186468;\n    extern u8 D_8018646C;\n    extern u8 D_80186474;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018646C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80186468); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186474); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CB010;\n    ((H16 *)&D_801CB020)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186470);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CB020;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:26", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80187E64;\n    extern u8 D_80187E68;\n    extern u8 D_80187E70;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80187E68);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80187E64); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80187E70); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D1E50;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801D1E60 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80187E6C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D1E60;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80187E64;\n    extern u8 D_80187E68;\n    extern u8 D_80187E70;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80187E68);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80187E64); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80187E70); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D1E50;\n    ((H16 *)&D_801D1E60)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80187E6C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D1E60;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:27", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801814C4;\n    extern u8 D_801814C8;\n    extern u8 D_801814D0;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801814C8);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801814C4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801814D0); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019AA48;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_8019AA58 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801814CC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019AA58;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801814C4;\n    extern u8 D_801814C8;\n    extern u8 D_801814D0;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801814C8);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801814C4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801814D0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019AA48;\n    ((H16 *)&D_8019AA58)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801814CC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019AA58;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:27", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80181044;\n    extern u8 D_80181048;\n    extern u8 D_80181050;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80181048);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80181044); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80181050); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80199500;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_80199510 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018104C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80199510;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80181044;\n    extern u8 D_80181048;\n    extern u8 D_80181050;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80181048);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80181044); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80181050); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80199500;\n    ((H16 *)&D_80199510)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018104C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80199510;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:27", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.249, "objects": ["build/src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186424;\n    extern u8 D_80186428;\n    extern u8 D_80186430;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186428);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80186424); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186430); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A9588;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801A9598 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018642C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A9598;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186424;\n    extern u8 D_80186428;\n    extern u8 D_80186430;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186428);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80186424); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186430); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A9588;\n    ((H16 *)&D_801A9598)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018642C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A9598;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:28", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801858B0;\n    extern u8 D_801858B4;\n    extern u8 D_801858BC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801858B4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801858B0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801858BC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C41F8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801C4208 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801858B8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C4208;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801858B0;\n    extern u8 D_801858B4;\n    extern u8 D_801858BC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801858B4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801858B0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801858BC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C41F8;\n    ((H16 *)&D_801C4208)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801858B8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C4208;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:28", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80183E58;\n    extern u8 D_80183E5C;\n    extern u8 D_80183E64;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80183E5C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80183E58); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80183E64); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019CA18;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_8019CA28 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80183E60);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019CA28;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80183E58;\n    extern u8 D_80183E5C;\n    extern u8 D_80183E64;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80183E5C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80183E58); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80183E64); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019CA18;\n    ((H16 *)&D_8019CA28)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80183E60);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019CA28;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:28", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184E7C;\n    extern u8 D_80184E80;\n    extern u8 D_80184E88;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184E80);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80184E7C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184E88); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C7150;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801C7160 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184E84);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C7160;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184E7C;\n    extern u8 D_80184E80;\n    extern u8 D_80184E88;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184E80);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80184E7C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184E88); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C7150;\n    ((H16 *)&D_801C7160)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184E84);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C7160;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:29", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801839B0;\n    extern u8 D_801839B4;\n    extern u8 D_801839BC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801839B4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801839B0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801839BC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BDEC8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801BDED8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801839B8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801BDED8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801839B0;\n    extern u8 D_801839B4;\n    extern u8 D_801839BC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801839B4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801839B0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801839BC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BDEC8;\n    ((H16 *)&D_801BDED8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801839B8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801BDED8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:29", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186710;\n    extern u8 D_80186714;\n    extern u8 D_8018671C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186714);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80186710); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018671C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8690;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801B86A0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186718);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B86A0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186710;\n    extern u8 D_80186714;\n    extern u8 D_8018671C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186714);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80186710); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018671C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8690;\n    ((H16 *)&D_801B86A0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186718);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B86A0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:29", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801846C0;\n    extern u8 D_801846C4;\n    extern u8 D_801846CC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801846C4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801846C0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801846CC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C3848;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801C3858 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801846C8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C3858;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801846C0;\n    extern u8 D_801846C4;\n    extern u8 D_801846CC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801846C4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801846C0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801846CC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C3848;\n    ((H16 *)&D_801C3858)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801846C8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C3858;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:30", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018B250;\n    extern u8 D_8018B254;\n    extern u8 D_8018B25C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018B254);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018B250); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018B25C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BEDE0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801BEDF0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018B258);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801BEDF0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018B250;\n    extern u8 D_8018B254;\n    extern u8 D_8018B25C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018B254);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018B250); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018B25C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BEDE0;\n    ((H16 *)&D_801BEDF0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018B258);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801BEDF0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:30", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018A8D8;\n    extern u8 D_8018A8DC;\n    extern u8 D_8018A8E4;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018A8DC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018A8D8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018A8E4); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8370;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801B8380 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018A8E0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B8380;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018A8D8;\n    extern u8 D_8018A8DC;\n    extern u8 D_8018A8E4;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018A8DC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018A8D8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018A8E4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8370;\n    ((H16 *)&D_801B8380)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018A8E0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B8380;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:30", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80181230;\n    extern u8 D_80181234;\n    extern u8 D_8018123C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80181234);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80181230); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018123C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A0660;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801A0670 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80181238);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A0670;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80181230;\n    extern u8 D_80181234;\n    extern u8 D_8018123C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80181234);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80181230); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018123C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A0660;\n    ((H16 *)&D_801A0670)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80181238);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A0670;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:31", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E8DC;\n    extern u8 D_8017E8E0;\n    extern u8 D_8017E8E8;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E8E0);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017E8DC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E8E8); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80199070;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_80199080 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E8E4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80199080;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E8DC;\n    extern u8 D_8017E8E0;\n    extern u8 D_8017E8E8;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E8E0);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017E8DC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E8E8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80199070;\n    ((H16 *)&D_80199080)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E8E4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80199080;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:31", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801822FC;\n    extern u8 D_80182300;\n    extern u8 D_80182308;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182300);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801822FC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182308); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A0E18;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801A0E28 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182304);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A0E28;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801822FC;\n    extern u8 D_80182300;\n    extern u8 D_80182308;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182300);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801822FC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182308); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A0E18;\n    ((H16 *)&D_801A0E28)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182304);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A0E28;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:31", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184EB0;\n    extern u8 D_80184EB4;\n    extern u8 D_80184EBC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184EB4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80184EB0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184EBC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8320;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801B8330 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184EB8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B8330;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184EB0;\n    extern u8 D_80184EB4;\n    extern u8 D_80184EBC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184EB4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80184EB0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184EBC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8320;\n    ((H16 *)&D_801B8330)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184EB8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B8330;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:31", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185CB8;\n    extern u8 D_80185CBC;\n    extern u8 D_80185CC4;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185CBC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80185CB8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80185CC4); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801ABB80;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801ABB90 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185CC0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801ABB90;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185CB8;\n    extern u8 D_80185CBC;\n    extern u8 D_80185CC4;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185CBC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80185CB8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80185CC4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801ABB80;\n    ((H16 *)&D_801ABB90)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80185CC0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801ABB90;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:32", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017EFD0;\n    extern u8 D_8017EFD4;\n    extern u8 D_8017EFDC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017EFD4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017EFD0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017EFDC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A83A8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801A83B8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017EFD8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A83B8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017EFD0;\n    extern u8 D_8017EFD4;\n    extern u8 D_8017EFDC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017EFD4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017EFD0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017EFDC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A83A8;\n    ((H16 *)&D_801A83B8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017EFD8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A83B8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:32", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80180A3C;\n    extern u8 D_80180A40;\n    extern u8 D_80180A48;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80180A40);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80180A3C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80180A48); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80193D00;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_80193D10 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80180A44);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80193D10;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80180A3C;\n    extern u8 D_80180A40;\n    extern u8 D_80180A48;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80180A40);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80180A3C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80180A48); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80193D00;\n    ((H16 *)&D_80193D10)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80180A44);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80193D10;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:32", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80183368;\n    extern u8 D_8018336C;\n    extern u8 D_80183374;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018336C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80183368); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80183374); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A4710;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801A4720 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80183370);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A4720;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80183368;\n    extern u8 D_8018336C;\n    extern u8 D_80183374;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018336C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80183368); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80183374); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A4710;\n    ((H16 *)&D_801A4720)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80183370);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A4720;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:33", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182E40;\n    extern u8 D_80182E44;\n    extern u8 D_80182E4C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182E44);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80182E40); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182E4C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80196890;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801968A0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182E48);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801968A0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182E40;\n    extern u8 D_80182E44;\n    extern u8 D_80182E4C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182E44);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80182E40); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182E4C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80196890;\n    ((H16 *)&D_801968A0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182E48);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801968A0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:33", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182714;\n    extern u8 D_80182718;\n    extern u8 D_80182720;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182718);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80182714); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182720); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801ADA00;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801ADA10 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018271C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801ADA10;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182714;\n    extern u8 D_80182718;\n    extern u8 D_80182720;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182718);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80182714); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182720); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801ADA00;\n    ((H16 *)&D_801ADA10)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018271C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801ADA10;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:33", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184E4C;\n    extern u8 D_80184E50;\n    extern u8 D_80184E58;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184E50);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80184E4C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184E58); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CD008;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801CD018 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184E54);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CD018;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184E4C;\n    extern u8 D_80184E50;\n    extern u8 D_80184E58;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184E50);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80184E4C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184E58); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CD008;\n    ((H16 *)&D_801CD018)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184E54);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CD018;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:34", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184310;\n    extern u8 D_80184314;\n    extern u8 D_8018431C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184314);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80184310); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018431C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C2E20;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801C2E30 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184318);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C2E30;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184310;\n    extern u8 D_80184314;\n    extern u8 D_8018431C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184314);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80184310); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018431C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C2E20;\n    ((H16 *)&D_801C2E30)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184318);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C2E30;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:34", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018B140;\n    extern u8 D_8018B144;\n    extern u8 D_8018B14C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018B144);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018B140); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018B14C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E0528;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801E0538 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018B148);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E0538;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018B140;\n    extern u8 D_8018B144;\n    extern u8 D_8018B14C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018B144);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018B140); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018B14C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E0528;\n    ((H16 *)&D_801E0538)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018B148);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E0538;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:34", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80183814;\n    extern u8 D_80183818;\n    extern u8 D_80183820;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80183818);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80183814); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80183820); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A8798;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801A87A8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018381C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A87A8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80183814;\n    extern u8 D_80183818;\n    extern u8 D_80183820;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80183818);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80183814); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80183820); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A8798;\n    ((H16 *)&D_801A87A8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018381C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A87A8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:35", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80188980;\n    extern u8 D_80188984;\n    extern u8 D_8018898C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80188984);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80188980); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018898C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BFAA8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801BFAB8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80188988);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801BFAB8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80188980;\n    extern u8 D_80188984;\n    extern u8 D_8018898C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80188984);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80188980); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018898C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BFAA8;\n    ((H16 *)&D_801BFAB8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80188988);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801BFAB8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:35", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018271C;\n    extern u8 D_80182720;\n    extern u8 D_80182728;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182720);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018271C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182728); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019A710;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_8019A720 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182724);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019A720;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018271C;\n    extern u8 D_80182720;\n    extern u8 D_80182728;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182720);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018271C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182728); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019A710;\n    ((H16 *)&D_8019A720)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182724);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019A720;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:35", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184C50;\n    extern u8 D_80184C54;\n    extern u8 D_80184C5C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184C54);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80184C50); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184C5C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B2510;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801B2520 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184C58);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B2520;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184C50;\n    extern u8 D_80184C54;\n    extern u8 D_80184C5C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184C54);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80184C50); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184C5C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B2510;\n    ((H16 *)&D_801B2520)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184C58);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B2520;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:36", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.478, "objects": ["build/src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.o", "build/src/ov_SC03_119/ov_SC03_119_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80189EF8;\n    extern u8 D_80189EFC;\n    extern u8 D_80189F04;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80189EFC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80189EF8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80189F04); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D2F58;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801D2F68 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80189F00);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D2F68;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80189EF8;\n    extern u8 D_80189EFC;\n    extern u8 D_80189F04;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80189EFC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80189EF8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80189F04); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D2F58;\n    ((H16 *)&D_801D2F68)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80189F00);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801D2F68;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:36", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80180164;\n    extern u8 D_80180168;\n    extern u8 D_80180170;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80180168);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80180164); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80180170); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019C990;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_8019C9A0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018016C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019C9A0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80180164;\n    extern u8 D_80180168;\n    extern u8 D_80180170;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80180168);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80180164); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80180170); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019C990;\n    ((H16 *)&D_8019C9A0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018016C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019C9A0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:37", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018611C;\n    extern u8 D_80186120;\n    extern u8 D_80186128;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186120);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018611C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186128); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B3F48;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801B3F58 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186124);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B3F58;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018611C;\n    extern u8 D_80186120;\n    extern u8 D_80186128;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186120);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018611C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186128); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B3F48;\n    ((H16 *)&D_801B3F58)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186124);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B3F58;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:37", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80188084;\n    extern u8 D_80188088;\n    extern u8 D_80188090;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80188088);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80188084); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80188090); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C06E8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801C06F8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018808C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C06F8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80188084;\n    extern u8 D_80188088;\n    extern u8 D_80188090;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80188088);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80188084); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80188090); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C06E8;\n    ((H16 *)&D_801C06F8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018808C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C06F8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:37", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F054;\n    extern u8 D_8017F058;\n    extern u8 D_8017F060;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F058);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017F054); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80190C20;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_80190C30 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F05C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80190C30;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F054;\n    extern u8 D_8017F058;\n    extern u8 D_8017F060;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F058);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017F054); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80190C20;\n    ((H16 *)&D_80190C30)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F05C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80190C30;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:38", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E72C;\n    extern u8 D_8017E730;\n    extern u8 D_8017E738;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E730);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017E72C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E738); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018E2C8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_8018E2D8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E734);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8018E2D8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E72C;\n    extern u8 D_8017E730;\n    extern u8 D_8017E738;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E730);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017E72C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E738); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018E2C8;\n    ((H16 *)&D_8018E2D8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E734);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8018E2D8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:38", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017EB90;\n    extern u8 D_8017EB94;\n    extern u8 D_8017EB9C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017EB94);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017EB90); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017EB9C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801909A0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801909B0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017EB98);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801909B0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017EB90;\n    extern u8 D_8017EB94;\n    extern u8 D_8017EB9C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017EB94);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017EB90); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017EB9C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801909A0;\n    ((H16 *)&D_801909B0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017EB98);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801909B0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:38", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F080;\n    extern u8 D_8017F084;\n    extern u8 D_8017F08C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F084);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017F080); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F08C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80196E30;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_80196E40 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F088);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80196E40;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F080;\n    extern u8 D_8017F084;\n    extern u8 D_8017F08C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F084);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017F080); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F08C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80196E30;\n    ((H16 *)&D_80196E40)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F088);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80196E40;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:39", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184AC8;\n    extern u8 D_80184ACC;\n    extern u8 D_80184AD4;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184ACC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80184AC8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184AD4); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C7688;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801C7698 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184AD0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C7698;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80184AC8;\n    extern u8 D_80184ACC;\n    extern u8 D_80184AD4;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80184ACC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80184AC8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184AD4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C7688;\n    ((H16 *)&D_801C7698)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80184AD0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C7698;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:39", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018058C;\n    extern u8 D_80180590;\n    extern u8 D_80180598;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80180590);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018058C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80180598); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A5830;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801A5840 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80180594);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A5840;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018058C;\n    extern u8 D_80180590;\n    extern u8 D_80180598;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80180590);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018058C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80180598); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A5830;\n    ((H16 *)&D_801A5840)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80180594);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A5840;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:39", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801838DC;\n    extern u8 D_801838E0;\n    extern u8 D_801838E8;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801838E0);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801838DC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801838E8); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BB090;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801BB0A0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801838E4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801BB0A0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801838DC;\n    extern u8 D_801838E0;\n    extern u8 D_801838E8;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801838E0);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801838DC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801838E8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BB090;\n    ((H16 *)&D_801BB0A0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801838E4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801BB0A0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:40", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E81C;\n    extern u8 D_8017E820;\n    extern u8 D_8017E828;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E820);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017E81C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E828); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80199818;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_80199828 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E824);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80199828;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E81C;\n    extern u8 D_8017E820;\n    extern u8 D_8017E828;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E820);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017E81C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E828); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80199818;\n    ((H16 *)&D_80199828)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E824);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80199828;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:40", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.25, "objects": ["build/src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185FF8;\n    extern u8 D_80185FFC;\n    extern u8 D_80186004;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185FFC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80185FF8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186004); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B48D8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801B48E8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186000);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B48E8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185FF8;\n    extern u8 D_80185FFC;\n    extern u8 D_80186004;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185FFC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80185FF8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186004); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B48D8;\n    ((H16 *)&D_801B48E8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186000);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B48E8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:40", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182AF0;\n    extern u8 D_80182AF4;\n    extern u8 D_80182AFC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182AF4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80182AF0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182AFC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801AB688;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801AB698 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182AF8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801AB698;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182AF0;\n    extern u8 D_80182AF4;\n    extern u8 D_80182AFC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182AF4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80182AF0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182AFC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801AB688;\n    ((H16 *)&D_801AB698)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182AF8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801AB698;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:41", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801829D0;\n    extern u8 D_801829D4;\n    extern u8 D_801829DC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801829D4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801829D0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801829DC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B0968;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801B0978 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801829D8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B0978;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801829D0;\n    extern u8 D_801829D4;\n    extern u8 D_801829DC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801829D4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801829D0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801829DC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B0968;\n    ((H16 *)&D_801B0978)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801829D8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B0978;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:41", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801807B8;\n    extern u8 D_801807BC;\n    extern u8 D_801807C4;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801807BC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801807B8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801807C4); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019EB78;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_8019EB88 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801807C0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019EB88;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801807B8;\n    extern u8 D_801807BC;\n    extern u8 D_801807C4;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801807BC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801807B8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801807C4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019EB78;\n    ((H16 *)&D_8019EB88)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801807C0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019EB88;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:41", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80181BFC;\n    extern u8 D_80181C00;\n    extern u8 D_80181C08;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80181C00);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80181BFC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80181C08); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019DD00;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_8019DD10 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80181C04);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019DD10;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80181BFC;\n    extern u8 D_80181C00;\n    extern u8 D_80181C08;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80181C00);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80181BFC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80181C08); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019DD00;\n    ((H16 *)&D_8019DD10)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80181C04);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019DD10;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:42", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F9F0;\n    extern u8 D_8017F9F4;\n    extern u8 D_8017F9FC;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F9F4);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017F9F0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F9FC); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018EAA0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_8018EAB0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F9F8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8018EAB0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F9F0;\n    extern u8 D_8017F9F4;\n    extern u8 D_8017F9FC;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F9F4);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017F9F0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F9FC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018EAA0;\n    ((H16 *)&D_8018EAB0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F9F8);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8018EAB0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:42", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182F44;\n    extern u8 D_80182F48;\n    extern u8 D_80182F50;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182F48);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80182F44); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182F50); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019FDB0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_8019FDC0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182F4C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019FDC0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182F44;\n    extern u8 D_80182F48;\n    extern u8 D_80182F50;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182F48);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80182F44); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182F50); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019FDB0;\n    ((H16 *)&D_8019FDC0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182F4C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019FDC0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:42", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80180FEC;\n    extern u8 D_80180FF0;\n    extern u8 D_80180FF8;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80180FF0);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80180FEC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80180FF8); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019BA80;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_8019BA90 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80180FF4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019BA90;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80180FEC;\n    extern u8 D_80180FF0;\n    extern u8 D_80180FF8;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80180FF0);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80180FEC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80180FF8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019BA80;\n    ((H16 *)&D_8019BA90)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80180FF4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019BA90;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:42", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F054;\n    extern u8 D_8017F058;\n    extern u8 D_8017F060;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F058);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017F054); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801957C0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801957D0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F05C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801957D0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F054;\n    extern u8 D_8017F058;\n    extern u8 D_8017F060;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F058);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017F054); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801957C0;\n    ((H16 *)&D_801957D0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F05C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801957D0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:43", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.469, "objects": ["build/src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.o", "build/src/ov_SC04_019/ov_SC04_019_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018D7A4;\n    extern u8 D_8018D7A8;\n    extern u8 D_8018D7B0;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018D7A8);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018D7A4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018D7B0); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E5A80;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801E5A90 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018D7AC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E5A90;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018D7A4;\n    extern u8 D_8018D7A8;\n    extern u8 D_8018D7B0;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018D7A8);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018D7A4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018D7B0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E5A80;\n    ((H16 *)&D_801E5A90)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018D7AC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801E5A90;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:43", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80188F30;\n    extern u8 D_80188F34;\n    extern u8 D_80188F3C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80188F34);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80188F30); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80188F3C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C5C10;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    D_801C5C20 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80188F38);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C5C20;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80188F30;\n    extern u8 D_80188F34;\n    extern u8 D_80188F3C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80188F34);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80188F30); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80188F3C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C5C10;\n    ((H16 *)&D_801C5C20)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80188F38);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801C5C20;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:44", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185224;\n    extern u8 D_80185228;\n    extern u8 D_80185230;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185228);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80185224); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80185230); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B0010;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    D_801B0020 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018522C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B0020;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80185224;\n    extern u8 D_80185228;\n    extern u8 D_80185230;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80185228);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80185224); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80185230); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B0010;\n    ((H16 *)&D_801B0020)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018522C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B0020;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:44", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801823E8;\n    extern u8 D_801823EC;\n    extern u8 D_801823F4;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801823EC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801823E8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801823F4); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8B68;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    D_801B8B78 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801823F0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B8B78;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801823E8;\n    extern u8 D_801823EC;\n    extern u8 D_801823F4;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801823EC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801823E8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801823F4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8B68;\n    ((H16 *)&D_801B8B78)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801823F0);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801B8B78;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:44", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80191DC4;\n    extern u8 D_80191DC8;\n    extern u8 D_80191DD0;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80191DC8);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80191DC4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80191DD0); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CF2D8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    D_801CF2E8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80191DCC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CF2E8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80191DC4;\n    extern u8 D_80191DC8;\n    extern u8 D_80191DD0;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80191DC8);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80191DC4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80191DD0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CF2D8;\n    ((H16 *)&D_801CF2E8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80191DCC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CF2E8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:45", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.248, "objects": ["build/src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018CAF8;\n    extern u8 D_8018CAFC;\n    extern u8 D_8018CB04;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018CAFC);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018CAF8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018CB04); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801DB908;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    D_801DB918 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018CB00);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801DB918;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018CAF8;\n    extern u8 D_8018CAFC;\n    extern u8 D_8018CB04;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018CAFC);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018CAF8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018CB04); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801DB908;\n    ((H16 *)&D_801DB918)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018CB00);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801DB918;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:45", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E564;\n    extern u8 D_8017E568;\n    extern u8 D_8017E570;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E568);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017E564); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E570); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019BFE8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    D_8019BFF8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E56C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019BFF8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E564;\n    extern u8 D_8017E568;\n    extern u8 D_8017E570;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E568);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017E564); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E570); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019BFE8;\n    ((H16 *)&D_8019BFF8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E56C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019BFF8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:45", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018FD80;\n    extern u8 D_8018FD84;\n    extern u8 D_8018FD8C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018FD84);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8018FD80); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018FD8C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801DFE48;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    D_801DFE58 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018FD88);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801DFE58;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8018FD80;\n    extern u8 D_8018FD84;\n    extern u8 D_8018FD8C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8018FD84);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8018FD80); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018FD8C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801DFE48;\n    ((H16 *)&D_801DFE58)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8018FD88);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801DFE58;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:46", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801938B4;\n    extern u8 D_801938B8;\n    extern u8 D_801938C0;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801938B8);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = p2[0]; pac = (*(s16 * *)&D_801938B4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801938C0); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CF218;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    D_801CF228 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801938BC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CF228;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_801938B4;\n    extern u8 D_801938B8;\n    extern u8 D_801938C0;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_801938B8);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_801938B4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801938C0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CF218;\n    ((H16 *)&D_801CF228)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_801938BC);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CF228;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:46", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182C0C;\n    extern u8 D_80182C10;\n    extern u8 D_80182C18;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182C10);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80182C0C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182C18); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CE820;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    D_801CE830 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182C14);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CE830;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80182C0C;\n    extern u8 D_80182C10;\n    extern u8 D_80182C18;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80182C10);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80182C0C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182C18); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CE820;\n    ((H16 *)&D_801CE830)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80182C14);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801CE830;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:46", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80181ABC;\n    extern u8 D_80181AC0;\n    extern u8 D_80181AC8;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80181AC0);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80181ABC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80181AC8); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A98D0;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    D_801A98E0 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80181AC4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A98E0;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80181ABC;\n    extern u8 D_80181AC0;\n    extern u8 D_80181AC8;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80181AC0);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80181ABC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80181AC8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A98D0;\n    ((H16 *)&D_801A98E0)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80181AC4);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A98E0;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:47", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017D890;\n    extern u8 D_8017D894;\n    extern u8 D_8017D89C;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017D894);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017D890); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017D89C); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80195308;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    D_80195318 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017D898);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80195318;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017D890;\n    extern u8 D_8017D894;\n    extern u8 D_8017D89C;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017D894);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017D890); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017D89C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80195308;\n    ((H16 *)&D_80195318)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017D898);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_80195318;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:47", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E334;\n    extern u8 D_8017E338;\n    extern u8 D_8017E340;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E338);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017E334); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E340); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A2998;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    D_801A29A8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E33C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A29A8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017E334;\n    extern u8 D_8017E338;\n    extern u8 D_8017E340;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017E338);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017E334); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E340); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A2998;\n    ((H16 *)&D_801A29A8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017E33C);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_801A29A8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:47", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.c", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": false, "includers": 0, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186D78;\n    extern u8 D_80186D7C;\n    extern u8 D_80186D84;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186D7C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = p2[0]; pac = (*(s16 * *)&D_80186D78); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186D84); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019A420;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    D_8019A430 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186D80);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019A430;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_80186D78;\n    extern u8 D_80186D7C;\n    extern u8 D_80186D84;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_80186D7C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_80186D78); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186D84); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019A420;\n    ((H16 *)&D_8019A430)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_80186D80);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8019A430;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:48", "label": "c1p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/shared/ov/func_80135168__bad0a585.h", "fn": "func_80135168", "addr": 2148749672, "aliases": null, "header": true, "includers": 3, "nhash_before": "58cab92c219487eb4e9329f4e9b78c4162fb27ba", "nhash_after": "0d1ac1fdb74442441e8aaa6296aeb7c6319c1cd5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135168", "verdict": "LEVER-FREE", "sites": [], "compiles": 3, "seconds": 0.711, "objects": ["build/src/ov_SC03_126/ov_SC03_126_jr_8012ACE0.o", "build/src/ov_SC04_021/ov_SC04_021_jr_8012ACE0.o", "build/src/ov_SC05_019/ov_SC05_019_jr_8012ACE0.o"], "before_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F808;\n    extern u8 D_8017F80C;\n    extern u8 D_8017F814;\n    register s16 *pb0 __asm__(\"$8\");  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B headers1)\n    register s16 *pac __asm__(\"$6\");  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B headers1)\n    register s16 *pb8 __asm__(\"$7\");  // !FAKE: pin $7 \u2014 NEEDED DIFFERS (P36 rung B headers1)\n    u16 *pb4;\n    u16 a, b;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F80C);\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B headers1)\n\n    a = p2[0]; pac = (*(s16 * *)&D_8017F808); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F814); pac[0] = b; pb8[0] = a - b;\n    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;\n    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018E6E8;\n    __asm__ __volatile__(\"\" ::: \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B headers1)\n    D_8018E6F8 = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F810);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8018E6F8;\n        return 1;\n    }\n    return 0;\n}\n", "after_text": "int func_80135168(u16 arg0, u16 *p1, u16 *p2)\n{\n    /* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every\n       LATER function in this TU, which blocks a byte-true decl of a different type.\n       Declaration-only move (cookbook \u00a7100); the whole-binary byte-gate is the arbiter. */\n    extern u8 D_8017F808;\n    extern u8 D_8017F80C;\n    extern u8 D_8017F814;\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int a1v, a2v, d94;\n\n    pb0 = (*(s16 * *)&D_8017F80C);\n\n    ax = p2[0]; pac = (*(s16 * *)&D_8017F808); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F814); pac[0] = bx; pb8[0] = ax - bx;\n    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;\n    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018E6E8;\n    ((H16 *)&D_8018E6F8)->h = 0;\n    if (func_80134A74(arg0, a1v, a2v, d94)) {\n        pb4 = (*(u16 * *)&D_8017F810);\n        p2[0] = pb4[0];\n        p2[1] = pb4[1];\n        p2[2] = pb4[2];\n        p2[3] = D_8018E6F8;\n        return 1;\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:49", "label": "c7", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "T7 agent c7", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801EDA40;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801EDA40 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801EDA40;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801EDA40 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:50", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_MAIN_012/ov_MAIN_012_jr_80131340.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.116, "objects": ["build/src/ov_MAIN_012/ov_MAIN_012_jr_80131340.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80184130;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_80184130 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80184130;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_80184130 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:50", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_107/ov_SC03_107_jr_80131340.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.119, "objects": ["build/src/ov_SC03_107/ov_SC03_107_jr_80131340.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019A788;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019A788 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019A788;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019A788 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:51", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_037/ov_SC02_037_jr_80131340.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.119, "objects": ["build/src/ov_SC02_037/ov_SC02_037_jr_80131340.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C8428;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C8428 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C8428;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C8428 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:51", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_077/ov_SC01_077_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC01_077/ov_SC01_077_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D9500;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801D9500 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D9500;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801D9500 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:51", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.253, "objects": ["build/src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A2060;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A2060 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A2060;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A2060 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:52", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.262, "objects": ["build/src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019A940;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019A940 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019A940;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019A940 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:52", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.255, "objects": ["build/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A4458;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A4458 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A4458;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A4458 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:52", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.263, "objects": ["build/src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801F1EC0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801F1EC0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801F1EC0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801F1EC0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:53", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.249, "objects": ["build/src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801EC6E8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801EC6E8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801EC6E8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801EC6E8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:53", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.25, "objects": ["build/src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E3010;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801E3010 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E3010;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801E3010 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:53", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.25, "objects": ["build/src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80194F98;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_80194F98 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80194F98;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_80194F98 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:54", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C4770;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C4770 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C4770;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C4770 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:54", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018EE50;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8018EE50 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018EE50;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8018EE50 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:54", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.246, "objects": ["build/src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C6218;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C6218 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C6218;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C6218 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:55", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E9EF0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801E9EF0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E9EF0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801E9EF0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:55", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.476, "objects": ["build/src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.o", "build/src/ov_SC01_006/ov_SC01_006_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CC5B0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801CC5B0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CC5B0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801CC5B0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:55", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018F070;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8018F070 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018F070;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8018F070 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:56", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.47, "objects": ["build/src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.o", "build/src/ov_SC02_003/ov_SC02_003_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E6D48;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801E6D48 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E6D48;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801E6D48 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:56", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801EE4B0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801EE4B0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801EE4B0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801EE4B0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:57", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80191A20;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_80191A20 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80191A20;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_80191A20 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:57", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B62E8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B62E8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B62E8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B62E8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:57", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D1B70;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801D1B70 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D1B70;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801D1B70 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:58", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B2C88;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B2C88 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B2C88;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B2C88 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:58", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D8BD0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801D8BD0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D8BD0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801D8BD0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:58", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CEE60;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801CEE60 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CEE60;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801CEE60 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:59", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801BD618;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801BD618 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801BD618;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801BD618 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:59", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019F9C8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019F9C8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019F9C8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019F9C8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:36:59", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CA440;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801CA440 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CA440;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801CA440 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:00", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B7D40;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B7D40 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B7D40;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B7D40 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:00", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801ED3C0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801ED3C0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801ED3C0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801ED3C0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:00", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018E748;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8018E748 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018E748;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8018E748 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:01", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801F60C0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801F60C0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801F60C0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801F60C0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:01", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E8A18;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801E8A18 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E8A18;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801E8A18 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:01", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A0F10;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A0F10 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A0F10;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A0F10 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:02", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019EC78;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019EC78 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019EC78;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019EC78 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:02", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801AC000;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801AC000 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801AC000;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801AC000 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:02", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80193D30;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_80193D30 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80193D30;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_80193D30 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:02", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801BFEF0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801BFEF0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801BFEF0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801BFEF0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:03", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80197958;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_80197958 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80197958;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_80197958 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:03", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801EA228;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801EA228 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801EA228;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801EA228 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:03", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D8200;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801D8200 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D8200;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801D8200 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:04", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.476, "objects": ["build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o", "build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E9580;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801E9580 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E9580;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801E9580 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:04", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C54B0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C54B0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C54B0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C54B0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:05", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D0FE8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801D0FE8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D0FE8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801D0FE8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:05", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C4BF8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C4BF8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C4BF8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C4BF8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:05", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CA918;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801CA918 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CA918;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801CA918 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:06", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E07F8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801E07F8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E07F8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801E07F8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:06", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CB020;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801CB020 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CB020;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801CB020 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:06", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B1BB0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B1BB0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B1BB0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B1BB0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:07", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019AA58;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019AA58 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019AA58;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019AA58 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:07", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D1E60;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801D1E60 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D1E60;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801D1E60 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:07", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80199510;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_80199510 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80199510;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_80199510 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:08", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A9598;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A9598 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A9598;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A9598 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:08", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C7160;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C7160 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C7160;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C7160 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:08", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801BDED8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801BDED8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801BDED8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801BDED8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:09", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C4208;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C4208 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C4208;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C4208 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:09", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C3858;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C3858 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C3858;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C3858 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:09", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019CA28;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019CA28 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019CA28;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019CA28 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:10", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B86A0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B86A0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B86A0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B86A0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:10", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B8380;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B8380 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B8380;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B8380 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:10", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801BEDF0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801BEDF0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801BEDF0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801BEDF0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:10", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80199080;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_80199080 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80199080;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_80199080 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:11", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A0670;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A0670 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A0670;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A0670 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:11", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A0E28;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A0E28 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A0E28;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A0E28 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:11", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B8330;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B8330 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B8330;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B8330 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:12", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801ABB90;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801ABB90 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801ABB90;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801ABB90 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:12", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CD018;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801CD018 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CD018;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801CD018 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:12", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A83B8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A83B8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A83B8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A83B8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:13", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80193D10;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_80193D10 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80193D10;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_80193D10 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:13", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A4720;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A4720 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A4720;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A4720 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:13", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801968A0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801968A0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801968A0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801968A0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:14", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801ADA10;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801ADA10 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801ADA10;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801ADA10 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:14", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.244, "objects": ["build/src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E0538;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801E0538 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E0538;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801E0538 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:14", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A87A8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A87A8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A87A8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A87A8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:15", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C2E30;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C2E30 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C2E30;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C2E30 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:15", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.473, "objects": ["build/src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.o", "build/src/ov_SC03_119/ov_SC03_119_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D2F68;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801D2F68 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D2F68;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801D2F68 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:16", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801BFAB8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801BFAB8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801BFAB8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801BFAB8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:16", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019C9A0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019C9A0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019C9A0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019C9A0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:16", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B2520;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B2520 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B2520;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B2520 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:17", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80196E40;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_80196E40 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80196E40;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_80196E40 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:17", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019A720;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019A720 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019A720;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019A720 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:17", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018E2D8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8018E2D8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018E2D8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8018E2D8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:18", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B3F58;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B3F58 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B3F58;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B3F58 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:18", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C06F8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C06F8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C06F8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C06F8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:18", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801909B0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801909B0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801909B0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801909B0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:18", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A5840;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A5840 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A5840;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A5840 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:19", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.242, "objects": ["build/src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C7698;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C7698 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C7698;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C7698 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:19", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80199828;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_80199828 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80199828;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_80199828 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:19", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801BB0A0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801BB0A0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801BB0A0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801BB0A0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:20", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801AB698;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801AB698 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801AB698;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801AB698 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:20", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019DD10;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019DD10 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019DD10;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019DD10 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:20", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B48E8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B48E8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B48E8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B48E8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:21", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.25, "objects": ["build/src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B0978;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B0978 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B0978;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B0978 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:21", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018EAB0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8018EAB0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018EAB0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8018EAB0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:21", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019EB88;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019EB88 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019EB88;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019EB88 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:22", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80190C30;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_80190C30 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80190C30;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_80190C30 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:22", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801957D0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801957D0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801957D0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801957D0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:22", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019BA90;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019BA90 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019BA90;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019BA90 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:23", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.479, "objects": ["build/src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.o", "build/src/ov_SC04_019/ov_SC04_019_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E5A90;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801E5A90 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E5A90;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801E5A90 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:23", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019FDC0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019FDC0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019FDC0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019FDC0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:24", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C5C20;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C5C20 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C5C20;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C5C20 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:24", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D3C58;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801D3C58 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801D3C58;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801D3C58 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:24", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019BDA8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019BDA8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019BDA8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019BDA8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:25", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801F6DB0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801F6DB0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801F6DB0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801F6DB0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:25", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801EB8E8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801EB8E8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801EB8E8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801EB8E8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:25", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E5028;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801E5028 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E5028;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801E5028 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:25", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.243, "objects": ["build/src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A8D30;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A8D30 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A8D30;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A8D30 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:26", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801997D0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801997D0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801997D0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801997D0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:26", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801AA918;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801AA918 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801AA918;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801AA918 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:26", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801AD368;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801AD368 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801AD368;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801AD368 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:27", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B0D68;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B0D68 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B0D68;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B0D68 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:27", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A01C0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A01C0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A01C0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A01C0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:27", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801935A0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801935A0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801935A0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801935A0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:28", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019E370;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019E370 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019E370;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019E370 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:28", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E0CD8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801E0CD8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801E0CD8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801E0CD8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:28", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B9470;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B9470 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B9470;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B9470 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:29", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_006/ov_SC07_006_jr_80131340.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.116, "objects": ["build/src/ov_SC07_006/ov_SC07_006_jr_80131340.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801F4DD8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801F4DD8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801F4DD8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801F4DD8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:29", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B0020;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B0020 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B0020;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B0020 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:29", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B8B78;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801B8B78 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801B8B78;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801B8B78 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:30", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CF2E8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801CF2E8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CF2E8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801CF2E8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:30", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801DB918;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801DB918 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801DB918;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801DB918 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:30", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019BFF8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019BFF8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019BFF8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019BFF8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:31", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801DFE58;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801DFE58 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801DFE58;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801DFE58 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:31", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CF228;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801CF228 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CF228;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801CF228 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:31", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CE830;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801CE830 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801CE830;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801CE830 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:31", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A98E0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A98E0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A98E0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A98E0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:32", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_007/ov_SC07_007_jr_80131340.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.115, "objects": ["build/src/ov_SC07_007/ov_SC07_007_jr_80131340.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C6540;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801C6540 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801C6540;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801C6540 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:32", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_010/ov_SC07_010_jr_80131340.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.113, "objects": ["build/src/ov_SC07_010/ov_SC07_010_jr_80131340.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A6A38;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A6A38 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A6A38;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A6A38 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:32", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_011/ov_SC07_011_jr_80131340.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.114, "objects": ["build/src/ov_SC07_011/ov_SC07_011_jr_80131340.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018F0D0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8018F0D0 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018F0D0;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8018F0D0 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:32", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80195318;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_80195318 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_80195318;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_80195318 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:33", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A29A8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_801A29A8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_801A29A8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_801A29A8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:33", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.c", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": false, "includers": 0, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019A430;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8019A430 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8019A430;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8019A430 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:37:34", "label": "c7p", "rung": "E", "calib": {"head": "205331765", "stamp": "b44c5a8a3423"}, "tu": "src/shared/ov/func_80134A74__38c10a1a.h", "fn": "func_80134A74", "addr": 2148747892, "aliases": null, "header": true, "includers": 3, "nhash_before": "fd328bff421875c3e477872f1337c5994a6268ac", "nhash_after": "266b753080d094a813817359fce34335dcf6f7ac", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80134A74", "verdict": "LEVER-FREE", "sites": [], "compiles": 3, "seconds": 0.723, "objects": ["build/src/ov_SC03_126/ov_SC03_126_jr_8012ACE0.o", "build/src/ov_SC04_021/ov_SC04_021_jr_8012ACE0.o", "build/src/ov_SC05_019/ov_SC05_019_jr_8012ACE0.o"], "before_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018E6F8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    u16 *param_4p = (u16 *)param_4;\n    register u32 zr __asm__(\"$0\");  // !FAKE: pin $0 \u2014 NEEDED DIFFERS (P36 rung A headers1)\n    u32 uVar6, uVar2, uVar2c;\n    u32 uVar6c;\n    u16 *puVar4, *ptmp;\n    register u32 n __asm__(\"$18\");  // !FAKE: pin $18 \u2014 NEEDED DIFFERS (P36 rung A headers1)\n    register u32 p0 __asm__(\"$4\");  // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung A headers1)\n    int v14;\n    u16 *puVar7, uVar1;\n    u32 hi, hic;\n    int iVar5, iVar9, iVar8, uVar3, uVar10;\n\n    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];\n    uVar6c = uVar6 + zr;\n    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {\n        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];\n        __asm__(\"addu %0,%1,$zero\" : \"=r\"(uVar2c) : \"r\"(uVar2));  // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung A headers1)\n        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;\n        return 0;\n    found:\n        D_8018E6F8 = *puVar7;\n        return 1;\n    work:\n        uVar10 = *(int *)(param_4p + 6);\n        uVar3 = *(int *)(param_4p + 8);\n        iVar9 = *(int *)(param_4p + 0xc);\n        iVar8 = *(int *)(param_4p + 0xe);\n        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));\n        v14 = *(int *)(param_4p + 10);\n        __asm__ __volatile__(\"\" :: \"r\"(uVar6c));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A headers1)\n        p0 = (u32)*ptmp;\n        n = (u32)ptmp[1];\n        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;\n        goto test;\n    body:\n        uVar1 = *puVar4;\n        hi = uVar1 & 0x8000;\n        hic = hi + zr;\n        if (hi == 0)\n            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);\n        else\n            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);\n        puVar4 = puVar4 - 1;\n        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);\n        if (iVar5 != 0) goto found;\n    test:\n        {\n            u32 m;\n            m = n;\n            n--;\n            if ((m & 0xffff) != 0) goto body;\n        }\n    }\n    return 0;\n}\n", "after_text": "int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)\n{\n    extern u16 D_8018E6F8;\n    extern s32 func_80134C20(s32, s32, s32, s32);\n\n    Map_80133AB0 *map = (Map_80133AB0 *)param_4;\n    u32 X, Y;\n    u16 Xc, Yc;\n    u16 k, off, cnt;\n    u16 *cp, *lst;\n    u16 raw;\n    u32 hib;\n    u16 harg;\n    u8 *s0;\n    void *p0C, *p10;\n    u8 *p14, *p18, *p1C;\n\n    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;\n    Xc = X;\n    if ((u16)X >= map->w)\n        return 0;\n    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;\n    Yc = Y;\n    if ((u16)Y >= map->h)\n        return 0;\n\n    p0C = map->p0C;\n    p10 = map->p10;\n    p18 = map->p18;\n    p1C = map->p1C;\n    k = (Yc * map->w + Xc) * 2;\n    cp = (u16 *)(k * 2 + (u32)map->cells);\n    p14 = map->p14;\n    off = cp[0];\n    cnt = cp[1];\n    lst = (u16 *)(p14 + off) + cnt - 1;\n\n    while (cnt-- != 0) {\n        raw = *lst;\n        hib = raw & 0x8000;\n        harg = hib;\n        if (hib == 0) {\n            s0 = p18 + raw * 18;\n            lst--;\n        } else {\n            s0 = p1C + (raw & 0x7fff) * 22;\n            lst--;\n        }\n        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {\n            D_8018E6F8 = *(u16 *)s0;\n            return 1;\n        }\n    }\n    return 0;\n}\n"}
+{"ts": "2026-09-10 14:45:02", "label": "eec0", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_000/ov_SC07_000_jr_8017ECB4.c", "fn": "func_8017EEC0", "addr": 2149052096, "aliases": null, "header": false, "includers": 0, "nhash_before": "bea57c4b91097b06ee97753cd46740f4b1acfb9d", "nhash_after": "fbf357f1ee36fba074b9210613aa7fd0f09246a3", "source": "S103 coordinator: the uninitialised a0v local left by T4 tus10 is the function parameter", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.05, "objects": ["build/src/ov_SC07_000/ov_SC07_000_jr_8017ECB4.o"], "before_text": "void func_8017EEC0(void) {\n    extern void func_8012AD44(s32 *a0, s16 a1);\n    s32 a0v;\n    func_8012AD44((s32 *)a0v, 3);\n}\n", "after_text": "void func_8017EEC0(s32 *a0) {\n    extern void func_8012AD44(s32 *a0, s16 a1);\n    func_8012AD44(a0, 3);\n}\n"}
+{"ts": "2026-09-10 14:45:02", "label": "c3", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_011/ov_SC04_011_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "T7 agent c3", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.318, "objects": ["build/src/ov_SC04_011/ov_SC04_011_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80191F24[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80191F24[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80191F24[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80191F24[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:04", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_006/ov_SC07_006_jr_801457A4.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC07_006/ov_SC07_006_jr_801457A4.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018BF04[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018BF04[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018BF04[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018BF04[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:04", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_011/ov_SC07_011_jr_801457A4.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.329, "objects": ["build/src/ov_SC07_011/ov_SC07_011_jr_801457A4.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80180178[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80180178[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80180178[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80180178[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:05", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_007/ov_SC07_007_jr_801457A4.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.332, "objects": ["build/src/ov_SC07_007/ov_SC07_007_jr_801457A4.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80184A28[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80184A28[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80184A28[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80184A28[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:05", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_010/ov_SC07_010_jr_801457A4.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.325, "objects": ["build/src/ov_SC07_010/ov_SC07_010_jr_801457A4.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80183AB8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80183AB8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus2)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus2)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80183AB8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80183AB8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:05", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_MAIN_012/ov_MAIN_012_jr_801458E0.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.32, "objects": ["build/src/ov_MAIN_012/ov_MAIN_012_jr_801458E0.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8017FE78[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8017FE78[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8017FE78[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8017FE78[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:06", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_001/ov_SC01_001_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.316, "objects": ["build/src/ov_SC01_001/ov_SC01_001_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80185350[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80185350[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80185350[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80185350[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:06", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_004/ov_SC01_004_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC01_004/ov_SC01_004_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80180D14[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80180D14[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80180D14[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80180D14[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:07", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_000/ov_SC01_000_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC01_000/ov_SC01_000_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80180700[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80180700[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80180700[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80180700[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:07", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_008/ov_SC01_008_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.318, "objects": ["build/src/ov_SC01_008/ov_SC01_008_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80181288[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80181288[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80181288[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80181288[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:07", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_009/ov_SC01_009_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.319, "objects": ["build/src/ov_SC01_009/ov_SC01_009_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80184470[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80184470[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80184470[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80184470[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:08", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_074/ov_SC01_074_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.324, "objects": ["build/src/ov_SC01_074/ov_SC01_074_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801800F0[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801800F0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801800F0[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801800F0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:08", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_080/ov_SC01_080_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.312, "objects": ["build/src/ov_SC01_080/ov_SC01_080_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80185050[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80185050[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80185050[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80185050[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:09", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_084/ov_SC01_084_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.312, "objects": ["build/src/ov_SC01_084/ov_SC01_084_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80188344[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80188344[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80188344[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80188344[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:09", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_005/ov_SC02_005_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.312, "objects": ["build/src/ov_SC02_005/ov_SC02_005_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801923D8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801923D8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801923D8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801923D8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:09", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_004/ov_SC02_004_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC02_004/ov_SC02_004_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8017F7D4[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8017F7D4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8017F7D4[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8017F7D4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:10", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_011/ov_SC02_011_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.316, "objects": ["build/src/ov_SC02_011/ov_SC02_011_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80192828[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80192828[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80192828[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80192828[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:10", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_015/ov_SC02_015_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.312, "objects": ["build/src/ov_SC02_015/ov_SC02_015_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8017FD3C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8017FD3C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8017FD3C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8017FD3C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:10", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_016/ov_SC02_016_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC02_016/ov_SC02_016_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80185F74[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80185F74[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80185F74[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80185F74[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:11", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_005/ov_SC01_005_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.639, "objects": ["build/src/ov_SC01_005/ov_SC01_005_after.o", "build/src/ov_SC01_006/ov_SC01_006_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80183EA8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80183EA8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80183EA8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80183EA8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:12", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_026/ov_SC02_026_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.318, "objects": ["build/src/ov_SC02_026/ov_SC02_026_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80187C14[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80187C14[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80187C14[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80187C14[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:12", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_027/ov_SC02_027_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.318, "objects": ["build/src/ov_SC02_027/ov_SC02_027_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018CD38[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018CD38[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018CD38[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018CD38[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:12", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_021/ov_SC02_021_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.319, "objects": ["build/src/ov_SC02_021/ov_SC02_021_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801815C0[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801815C0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801815C0[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801815C0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:13", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_017/ov_SC02_017_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.316, "objects": ["build/src/ov_SC02_017/ov_SC02_017_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018BFCC[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018BFCC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018BFCC[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018BFCC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:13", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_028/ov_SC02_028_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC02_028/ov_SC02_028_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018CF3C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018CF3C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018CF3C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018CF3C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:14", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_000/ov_SC02_000_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.635, "objects": ["build/src/ov_SC02_000/ov_SC02_000_after.o", "build/src/ov_SC02_003/ov_SC02_003_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018C6F4[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018C6F4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018C6F4[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018C6F4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:14", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_035/ov_SC02_035_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.322, "objects": ["build/src/ov_SC02_035/ov_SC02_035_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80185FC8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80185FC8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80185FC8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80185FC8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:15", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_037/ov_SC02_037_jr_801458E0.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.323, "objects": ["build/src/ov_SC02_037/ov_SC02_037_jr_801458E0.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80185704[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80185704[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80185704[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80185704[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:15", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_031/ov_SC02_031_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.319, "objects": ["build/src/ov_SC02_031/ov_SC02_031_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80186768[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80186768[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80186768[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80186768[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:15", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_041/ov_SC02_041_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC02_041/ov_SC02_041_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801868C4[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801868C4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801868C4[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801868C4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:16", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_039/ov_SC02_039_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.315, "objects": ["build/src/ov_SC02_039/ov_SC02_039_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80180BF4[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80180BF4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80180BF4[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80180BF4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:16", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_001/ov_SC03_001_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.315, "objects": ["build/src/ov_SC03_001/ov_SC03_001_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018F004[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018F004[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018F004[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018F004[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:17", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_006/ov_SC03_006_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.318, "objects": ["build/src/ov_SC03_006/ov_SC03_006_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018E0D8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018E0D8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018E0D8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018E0D8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:17", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_002/ov_SC03_002_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.311, "objects": ["build/src/ov_SC03_002/ov_SC03_002_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80186FF4[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80186FF4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80186FF4[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80186FF4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:17", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_003/ov_SC03_003_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.322, "objects": ["build/src/ov_SC03_003/ov_SC03_003_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80180DBC[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80180DBC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80180DBC[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80180DBC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:18", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_007/ov_SC03_007_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC03_007/ov_SC03_007_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80188ED0[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80188ED0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80188ED0[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80188ED0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:18", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_010/ov_SC03_010_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.32, "objects": ["build/src/ov_SC03_010/ov_SC03_010_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801819F0[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801819F0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801819F0[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801819F0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:19", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_011/ov_SC03_011_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.319, "objects": ["build/src/ov_SC03_011/ov_SC03_011_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80182D60[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80182D60[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80182D60[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80182D60[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:19", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_012/ov_SC03_012_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC03_012/ov_SC03_012_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8017FC40[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8017FC40[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8017FC40[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8017FC40[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:19", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_024/ov_SC03_024_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.32, "objects": ["build/src/ov_SC03_024/ov_SC03_024_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80188A04[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80188A04[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80188A04[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80188A04[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:20", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_023/ov_SC03_023_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.318, "objects": ["build/src/ov_SC03_023/ov_SC03_023_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801809E0[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801809E0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801809E0[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801809E0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:20", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_013/ov_SC03_013_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.323, "objects": ["build/src/ov_SC03_013/ov_SC03_013_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80182A28[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80182A28[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80182A28[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80182A28[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:21", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_028/ov_SC03_028_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.321, "objects": ["build/src/ov_SC03_028/ov_SC03_028_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018D4D0[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018D4D0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018D4D0[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018D4D0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:21", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_029/ov_SC03_029_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.318, "objects": ["build/src/ov_SC03_029/ov_SC03_029_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80189308[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80189308[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80189308[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80189308[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:21", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_031/ov_SC03_031_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.322, "objects": ["build/src/ov_SC03_031/ov_SC03_031_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80183E60[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80183E60[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80183E60[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80183E60[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:22", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_089/ov_SC03_089_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.32, "objects": ["build/src/ov_SC03_089/ov_SC03_089_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018B15C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018B15C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018B15C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018B15C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:22", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_030/ov_SC03_030_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC03_030/ov_SC03_030_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80183944[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80183944[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80183944[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80183944[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:23", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_090/ov_SC03_090_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC03_090/ov_SC03_090_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018D580[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018D580[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018D580[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018D580[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:23", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_091/ov_SC03_091_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.315, "objects": ["build/src/ov_SC03_091/ov_SC03_091_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018E428[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018E428[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018E428[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018E428[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:23", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_092/ov_SC03_092_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.315, "objects": ["build/src/ov_SC03_092/ov_SC03_092_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801867F8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801867F8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801867F8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801867F8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:24", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_014/ov_SC03_014_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.625, "objects": ["build/src/ov_SC03_014/ov_SC03_014_after.o", "build/src/ov_SC03_015/ov_SC03_015_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018D064[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018D064[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018D064[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018D064[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:24", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_095/ov_SC03_095_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.315, "objects": ["build/src/ov_SC03_095/ov_SC03_095_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80182A2C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80182A2C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80182A2C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80182A2C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:25", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_093/ov_SC03_093_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC03_093/ov_SC03_093_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801879D0[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801879D0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801879D0[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801879D0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:25", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_094/ov_SC03_094_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC03_094/ov_SC03_094_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801893CC[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801893CC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801893CC[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801893CC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:26", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_096/ov_SC03_096_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC03_096/ov_SC03_096_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801825AC[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801825AC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801825AC[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801825AC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:26", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_097/ov_SC03_097_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.315, "objects": ["build/src/ov_SC03_097/ov_SC03_097_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018798C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018798C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018798C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018798C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:26", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_098/ov_SC03_098_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.316, "objects": ["build/src/ov_SC03_098/ov_SC03_098_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80186E18[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80186E18[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80186E18[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80186E18[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:27", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_099/ov_SC03_099_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC03_099/ov_SC03_099_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80184F18[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80184F18[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80184F18[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80184F18[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:27", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_101/ov_SC03_101_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.315, "objects": ["build/src/ov_SC03_101/ov_SC03_101_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801853C0[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801853C0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801853C0[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801853C0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:28", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_100/ov_SC03_100_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.315, "objects": ["build/src/ov_SC03_100/ov_SC03_100_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801863E4[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801863E4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801863E4[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801863E4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:28", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_102/ov_SC03_102_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.319, "objects": ["build/src/ov_SC03_102/ov_SC03_102_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80187C78[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80187C78[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80187C78[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80187C78[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:28", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_104/ov_SC03_104_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.315, "objects": ["build/src/ov_SC03_104/ov_SC03_104_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018C7B8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018C7B8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018C7B8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018C7B8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:29", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_103/ov_SC03_103_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.316, "objects": ["build/src/ov_SC03_103/ov_SC03_103_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80185C28[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80185C28[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80185C28[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80185C28[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:29", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_107/ov_SC03_107_jr_801458E0.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC03_107/ov_SC03_107_jr_801458E0.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80183FA0[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80183FA0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80183FA0[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80183FA0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:30", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_105/ov_SC03_105_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC03_105/ov_SC03_105_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018BE40[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018BE40[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018BE40[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018BE40[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:30", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_108/ov_SC03_108_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC03_108/ov_SC03_108_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80182798[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80182798[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80182798[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80182798[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:30", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_109/ov_SC03_109_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.32, "objects": ["build/src/ov_SC03_109/ov_SC03_109_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8017FE44[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8017FE44[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8017FE44[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8017FE44[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:31", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_111/ov_SC03_111_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.321, "objects": ["build/src/ov_SC03_111/ov_SC03_111_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80186418[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80186418[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80186418[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80186418[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:31", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_110/ov_SC03_110_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.316, "objects": ["build/src/ov_SC03_110/ov_SC03_110_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80183864[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80183864[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80183864[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80183864[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:31", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_112/ov_SC03_112_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.316, "objects": ["build/src/ov_SC03_112/ov_SC03_112_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80187220[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80187220[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80187220[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80187220[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:32", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_114/ov_SC03_114_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.32, "objects": ["build/src/ov_SC03_114/ov_SC03_114_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80180538[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80180538[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80180538[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80180538[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:32", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_113/ov_SC03_113_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.316, "objects": ["build/src/ov_SC03_113/ov_SC03_113_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801848D0[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801848D0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801848D0[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801848D0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:33", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_116/ov_SC03_116_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.315, "objects": ["build/src/ov_SC03_116/ov_SC03_116_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801843A8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801843A8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801843A8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801843A8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:33", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_117/ov_SC03_117_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.312, "objects": ["build/src/ov_SC03_117/ov_SC03_117_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801863B4[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801863B4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801863B4[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801863B4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:33", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_115/ov_SC03_115_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC03_115/ov_SC03_115_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80181FA4[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80181FA4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80181FA4[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80181FA4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:34", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_121/ov_SC03_121_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC03_121/ov_SC03_121_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80183C7C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80183C7C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80183C7C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80183C7C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:34", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_124/ov_SC03_124_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.318, "objects": ["build/src/ov_SC03_124/ov_SC03_124_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018C6A8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018C6A8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018C6A8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018C6A8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:35", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_125/ov_SC03_125_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.315, "objects": ["build/src/ov_SC03_125/ov_SC03_125_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80185878[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80185878[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80185878[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80185878[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:35", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_002/ov_SC04_002_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC04_002/ov_SC04_002_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80189EE8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80189EE8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80189EE8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80189EE8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:35", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_003/ov_SC04_003_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.32, "objects": ["build/src/ov_SC04_003/ov_SC04_003_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80183C84[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80183C84[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80183C84[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80183C84[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:36", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_000/ov_SC04_000_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.312, "objects": ["build/src/ov_SC04_000/ov_SC04_000_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80184D7C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80184D7C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80184D7C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80184D7C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:36", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_004/ov_SC04_004_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC04_004/ov_SC04_004_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801861B8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801861B8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801861B8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801861B8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:37", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_005/ov_SC04_005_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.318, "objects": ["build/src/ov_SC04_005/ov_SC04_005_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801895EC[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801895EC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801895EC[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801895EC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:37", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_006/ov_SC04_006_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.321, "objects": ["build/src/ov_SC04_006/ov_SC04_006_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801816CC[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801816CC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801816CC[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801816CC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:37", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_007/ov_SC04_007_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.328, "objects": ["build/src/ov_SC04_007/ov_SC04_007_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80187684[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80187684[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80187684[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80187684[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:38", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_009/ov_SC04_009_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.319, "objects": ["build/src/ov_SC04_009/ov_SC04_009_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801805E8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801805E8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801805E8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801805E8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:38", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_010/ov_SC04_010_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.318, "objects": ["build/src/ov_SC04_010/ov_SC04_010_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8017FC94[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8017FC94[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8017FC94[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8017FC94[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:39", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_118/ov_SC03_118_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.632, "objects": ["build/src/ov_SC03_118/ov_SC03_118_after.o", "build/src/ov_SC03_119/ov_SC03_119_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018B460[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018B460[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018B460[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018B460[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:39", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_012/ov_SC04_012_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC04_012/ov_SC04_012_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801800F8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801800F8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801800F8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801800F8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:40", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_015/ov_SC04_015_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC04_015/ov_SC04_015_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80186030[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80186030[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80186030[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80186030[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:40", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_016/ov_SC04_016_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC04_016/ov_SC04_016_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80181AF4[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80181AF4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80181AF4[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80181AF4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:40", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_020/ov_SC04_020_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC04_020/ov_SC04_020_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80184E44[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80184E44[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80184E44[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80184E44[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:41", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_000/ov_SC05_000_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.311, "objects": ["build/src/ov_SC05_000/ov_SC05_000_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8017FD84[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8017FD84[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8017FD84[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8017FD84[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:41", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_001/ov_SC05_001_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC05_001/ov_SC05_001_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80187560[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80187560[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80187560[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80187560[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:42", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_002/ov_SC05_002_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.319, "objects": ["build/src/ov_SC05_002/ov_SC05_002_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80181D20[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80181D20[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80181D20[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80181D20[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:42", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_003/ov_SC05_003_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC05_003/ov_SC05_003_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80184058[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80184058[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80184058[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80184058[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:42", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_006/ov_SC05_006_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC05_006/ov_SC05_006_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80180F58[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80180F58[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80180F58[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80180F58[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:43", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_007/ov_SC05_007_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.316, "objects": ["build/src/ov_SC05_007/ov_SC05_007_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80182554[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80182554[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80182554[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80182554[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:43", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_004/ov_SC05_004_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.316, "objects": ["build/src/ov_SC05_004/ov_SC05_004_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80183164[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80183164[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80183164[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80183164[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:44", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_005/ov_SC05_005_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.312, "objects": ["build/src/ov_SC05_005/ov_SC05_005_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80183F38[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80183F38[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80183F38[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80183F38[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:44", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_008/ov_SC05_008_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC05_008/ov_SC05_008_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801844AC[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801844AC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801844AC[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801844AC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:44", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_010/ov_SC05_010_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.31, "objects": ["build/src/ov_SC05_010/ov_SC05_010_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018A498[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018A498[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018A498[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018A498[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:45", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_011/ov_SC05_011_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC05_011/ov_SC05_011_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8017F810[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8017F810[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8017F810[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8017F810[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:45", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_018/ov_SC04_018_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.621, "objects": ["build/src/ov_SC04_018/ov_SC04_018_after.o", "build/src/ov_SC04_019/ov_SC04_019_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018ED0C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018ED0C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018ED0C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018ED0C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:46", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_017/ov_SC05_017_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC05_017/ov_SC05_017_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018ECD0[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018ECD0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018ECD0[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018ECD0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:46", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_018/ov_SC05_018_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC05_018/ov_SC05_018_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018842C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018842C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018842C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018842C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:47", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_000/ov_SC06_000_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC06_000/ov_SC06_000_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80189D80[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80189D80[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80189D80[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80189D80[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:47", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_006/ov_SC06_006_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.309, "objects": ["build/src/ov_SC06_006/ov_SC06_006_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801838A4[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801838A4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801838A4[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801838A4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:47", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_008/ov_SC06_008_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.318, "objects": ["build/src/ov_SC06_008/ov_SC06_008_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018730C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018730C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018730C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018730C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:48", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_011/ov_SC06_011_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.312, "objects": ["build/src/ov_SC06_011/ov_SC06_011_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80181F48[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80181F48[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80181F48[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80181F48[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:48", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_010/ov_SC06_010_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.311, "objects": ["build/src/ov_SC06_010/ov_SC06_010_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801884E8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801884E8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801884E8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801884E8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:49", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_013/ov_SC06_013_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC06_013/ov_SC06_013_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801806C4[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801806C4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801806C4[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801806C4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:49", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_014/ov_SC06_014_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.31, "objects": ["build/src/ov_SC06_014/ov_SC06_014_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80181A28[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80181A28[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80181A28[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80181A28[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:49", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_015/ov_SC06_015_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.312, "objects": ["build/src/ov_SC06_015/ov_SC06_015_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80180580[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80180580[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80180580[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80180580[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:50", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_016/ov_SC06_016_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC06_016/ov_SC06_016_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80186990[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80186990[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80186990[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80186990[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:50", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_018/ov_SC06_018_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.319, "objects": ["build/src/ov_SC06_018/ov_SC06_018_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801950CC[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801950CC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801950CC[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801950CC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:50", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_020/ov_SC06_020_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.319, "objects": ["build/src/ov_SC06_020/ov_SC06_020_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80186B54[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80186B54[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80186B54[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80186B54[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:51", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_022/ov_SC06_022_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.311, "objects": ["build/src/ov_SC06_022/ov_SC06_022_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018EE10[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018EE10[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018EE10[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018EE10[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:51", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_024/ov_SC06_024_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.312, "objects": ["build/src/ov_SC06_024/ov_SC06_024_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801912E8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801912E8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801912E8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801912E8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:52", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_025/ov_SC06_025_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.318, "objects": ["build/src/ov_SC06_025/ov_SC06_025_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018678C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018678C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus4)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018678C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018678C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:52", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_033/ov_SC06_033_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.32, "objects": ["build/src/ov_SC06_033/ov_SC06_033_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8019332C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus5)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8019332C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8019332C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8019332C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:52", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_009/ov_SC07_009_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.315, "objects": ["build/src/ov_SC07_009/ov_SC07_009_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8017F89C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus5)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8017F89C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8017F89C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8017F89C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:53", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_000/ov_SC07_000_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.311, "objects": ["build/src/ov_SC07_000/ov_SC07_000_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80184174[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus5)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80184174[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80184174[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80184174[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:53", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_032/ov_SC06_032_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.32, "objects": ["build/src/ov_SC06_032/ov_SC06_032_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80194E1C[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus5)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80194E1C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80194E1C[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80194E1C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:54", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_029/ov_SC06_029_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.321, "objects": ["build/src/ov_SC06_029/ov_SC06_029_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8018E060[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus5)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8018E060[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8018E060[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8018E060[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:54", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_030/ov_SC06_030_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC06_030/ov_SC06_030_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80183950[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus5)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80183950[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80183950[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80183950[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:54", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_002/ov_SC07_002_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.319, "objects": ["build/src/ov_SC07_002/ov_SC07_002_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801882E0[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus5)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801882E0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801882E0[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801882E0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:55", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_008/ov_SC07_008_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.317, "objects": ["build/src/ov_SC07_008/ov_SC07_008_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8017EDF8[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus5)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8017EDF8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8017EDF8[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8017EDF8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:55", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_001/ov_SC07_001_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.314, "objects": ["build/src/ov_SC07_001/ov_SC07_001_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80183024[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus5)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80183024[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80183024[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80183024[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:56", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_027/ov_SC06_027_after.c", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": false, "includers": 0, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.313, "objects": ["build/src/ov_SC06_027/ov_SC06_027_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_8017FACC[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung B tus5)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_8017FACC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung B tus5)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung B tus5)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_8017FACC[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_8017FACC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:57", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/shared/ov/func_80148AFC__4d5b7f00.h", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": true, "includers": 3, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 3, "seconds": 0.951, "objects": ["build/src/ov_SC03_126/ov_SC03_126_after.o", "build/src/ov_SC04_021/ov_SC04_021_after.o", "build/src/ov_SC05_019/ov_SC05_019_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_80180D70[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung A headers2)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_80180D70[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung A headers2)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_80180D70[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_80180D70[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:45:57", "label": "c3p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/shared/ov/func_80148AFC__a6049646.h", "fn": "func_80148AFC", "addr": 2148829948, "aliases": null, "header": true, "includers": 2, "nhash_before": "12ecadf44d54c1f5db660d7fe10e8c192072e0a7", "nhash_after": "0cbff40c35cd7f98519c33fa669d174d54170c93", "source": "propagate:src/ov_SC04_011/ov_SC04_011_after.c:func_80148AFC", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.636, "objects": ["build/src/ov_SC04_008/ov_SC04_008_after.o", "build/src/ov_SC05_009/ov_SC05_009_after.o"], "before_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern ActorFn D_801805BC[];\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    register s32 tmp __asm__(\"$5\") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 sVar3;\n    u8 bVar1;\n    __asm__(\"\" : \"=r\"(tmp) : \"0\"(tmp));  // !FAKE: launder \u2014 NEEDED DIFFERS (P36 rung A headers2)\n    sVar3 = tmp;\n    bVar1 = *(u8 *)(p + 0xA9);\n\n    switch (bVar1) {\n    case 0x41:\n        return D_801805BC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;\n    case 0x53:\n    case 0x73:\n        {\n            register u32 bb __asm__(\"$3\");  // !FAKE: pin $3 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n            register s32 c80 __asm__(\"$2\") = 0x80;  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n            s32 lo;\n            register s32 hi __asm__(\"$2\");  // !FAKE: pin $2 \u2014 NEEDED DIFFERS (P36 rung A headers2)\n            bb = *(u16 *)(p + 0xAE);\n            lo = bb & 0xFF;\n            if (lo != c80 || (hi = bb >> 8) != 0x80) {\n                s32 sVar4;\n                __asm__ __volatile__(\"\" : : : \"memory\");  // !FAKE: barrier memory \u2014 NEEDED DIFFERS (P36 rung A headers2)\n                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;\n                return 1;\n            }\n            return 0;\n        }\n    }\n}\n", "after_text": "int func_80148AFC(void *a0) {\n\n    extern s32 D_801151D4;\n    extern s32 (*D_801805BC[])(void *, s32);\n    s32 p = (s32)a0;\n    s32 iVar5 = *(s32 *)(p + 0x20);\n    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),\n                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;\n    s32 ang = tmp;\n\n    switch (*(u8 *)(p + 0xA9)) {\n    case 0x41:\n        return D_801805BC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;\n    case 0x53:\n    case 0x73:\n        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {\n            return 0;\n        }\n        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));\n        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;\n        return 1;\n    }\n}\n"}
+{"ts": "2026-09-10 14:47:06", "label": "c5", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "T7 agent c5", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80192A8C[];\n    extern u8 D_80192A9C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80192AC8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80192A8C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80192A9C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80192D0C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80192D0C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80192D0C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80192AC8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80192A8C[];\n    extern u8 D_80192A9C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80192AC8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80192A8C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80192A9C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80192D0C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80192D0C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80192D0C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80192AC8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:08", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_000/ov_SC01_000_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.297, "objects": ["build/src/ov_SC01_000/ov_SC01_000_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181268[];\n    extern u8 D_80181278[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801812A4[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181268);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181278);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801814E8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801814E8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801814E8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801812A4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181268[];\n    extern u8 D_80181278[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801812A4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181268);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181278);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801814E8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801814E8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801814E8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801812A4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:08", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.294, "objects": ["build/src/ov_SC01_077/ov_SC01_077_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018917C[];\n    extern u8 D_8018918C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801891B8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018917C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018918C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801893FC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801893FC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801893FC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801891B8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018917C[];\n    extern u8 D_8018918C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801891B8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018917C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018918C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801893FC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801893FC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801893FC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801891B8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:09", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_004/ov_SC02_004_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.294, "objects": ["build/src/ov_SC02_004/ov_SC02_004_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018033C[];\n    extern u8 D_8018034C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80180378[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018033C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018034C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801805BC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801805BC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801805BC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180378[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018033C[];\n    extern u8 D_8018034C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80180378[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018033C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018034C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801805BC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801805BC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801805BC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180378[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:09", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_004/ov_SC01_004_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC01_004/ov_SC01_004_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018187C[];\n    extern u8 D_8018188C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801818B8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018187C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018188C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80181AFC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80181AFC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80181AFC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801818B8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018187C[];\n    extern u8 D_8018188C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801818B8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018187C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018188C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80181AFC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80181AFC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80181AFC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801818B8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:09", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_084/ov_SC01_084_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC01_084/ov_SC01_084_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80188EAC[];\n    extern u8 D_80188EBC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80188EE8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188EAC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188EBC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018912C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018912C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018912C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188EE8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80188EAC[];\n    extern u8 D_80188EBC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80188EE8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188EAC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188EBC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018912C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018912C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018912C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188EE8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:10", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_005/ov_SC02_005_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.294, "objects": ["build/src/ov_SC02_005/ov_SC02_005_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80192F40[];\n    extern u8 D_80192F50[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80192F7C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80192F40);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80192F50);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801931C0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801931C0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801931C0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80192F7C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80192F40[];\n    extern u8 D_80192F50[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80192F7C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80192F40);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80192F50);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801931C0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801931C0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801931C0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80192F7C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:10", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_009/ov_SC01_009_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.297, "objects": ["build/src/ov_SC01_009/ov_SC01_009_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80184FD8[];\n    extern u8 D_80184FE8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80185014[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184FD8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184FE8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185258[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185258[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185258[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185014[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80184FD8[];\n    extern u8 D_80184FE8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80185014[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184FD8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184FE8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185258[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185258[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185258[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185014[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:11", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_011/ov_SC02_011_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.295, "objects": ["build/src/ov_SC02_011/ov_SC02_011_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80193390[];\n    extern u8 D_801933A0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801933CC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80193390);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801933A0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80193610[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80193610[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80193610[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801933CC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80193390[];\n    extern u8 D_801933A0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801933CC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80193390);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801933A0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80193610[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80193610[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80193610[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801933CC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:11", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_080/ov_SC01_080_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.296, "objects": ["build/src/ov_SC01_080/ov_SC01_080_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80185BB8[];\n    extern u8 D_80185BC8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80185BF4[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185BB8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185BC8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185E38[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185E38[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185E38[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185BF4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80185BB8[];\n    extern u8 D_80185BC8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80185BF4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185BB8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185BC8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185E38[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185E38[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185E38[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185BF4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:12", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_074/ov_SC01_074_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC01_074/ov_SC01_074_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80180C58[];\n    extern u8 D_80180C68[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80180C94[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180C58);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180C68);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180ED8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180ED8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180ED8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180C94[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80180C58[];\n    extern u8 D_80180C68[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80180C94[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180C58);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180C68);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180ED8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180ED8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180ED8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180C94[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:12", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_001/ov_SC01_001_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.297, "objects": ["build/src/ov_SC01_001/ov_SC01_001_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80185EB8[];\n    extern u8 D_80185EC8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80185EF4[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185EB8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185EC8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186138[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186138[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186138[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185EF4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80185EB8[];\n    extern u8 D_80185EC8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80185EF4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185EB8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185EC8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186138[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186138[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186138[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185EF4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:13", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_008/ov_SC01_008_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.303, "objects": ["build/src/ov_SC01_008/ov_SC01_008_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181DF0[];\n    extern u8 D_80181E00[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80181E2C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181DF0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181E00);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80182070[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80182070[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80182070[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181E2C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181DF0[];\n    extern u8 D_80181E00[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80181E2C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181DF0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181E00);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80182070[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80182070[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80182070[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181E2C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:13", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_015/ov_SC02_015_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.299, "objects": ["build/src/ov_SC02_015/ov_SC02_015_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801808A4[];\n    extern u8 D_801808B4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801808E0[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801808A4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801808B4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180B24[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180B24[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180B24[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801808E0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801808A4[];\n    extern u8 D_801808B4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801808E0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801808A4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801808B4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180B24[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180B24[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180B24[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801808E0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:14", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_016/ov_SC02_016_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.297, "objects": ["build/src/ov_SC02_016/ov_SC02_016_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186ADC[];\n    extern u8 D_80186AEC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80186B18[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186ADC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186AEC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186D5C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186D5C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186D5C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186B18[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186ADC[];\n    extern u8 D_80186AEC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80186B18[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186ADC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186AEC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186D5C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186D5C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186D5C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186B18[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:14", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_017/ov_SC02_017_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC02_017/ov_SC02_017_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018CB34[];\n    extern u8 D_8018CB44[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018CB70[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018CB34);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018CB44);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018CDB4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018CDB4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018CDB4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018CB70[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018CB34[];\n    extern u8 D_8018CB44[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018CB70[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018CB34);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018CB44);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018CDB4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018CDB4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018CDB4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018CB70[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:15", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_005/ov_SC01_005_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.582, "objects": ["build/src/ov_SC01_005/ov_SC01_005_jr_8015C32C.o", "build/src/ov_SC01_006/ov_SC01_006_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80184A10[];\n    extern u8 D_80184A20[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80184A4C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184A10);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184A20);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184C90[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184C90[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184C90[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184A4C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80184A10[];\n    extern u8 D_80184A20[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80184A4C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184A10);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184A20);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184C90[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184C90[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184C90[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184A4C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:15", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_000/ov_SC02_000_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.589, "objects": ["build/src/ov_SC02_000/ov_SC02_000_jr_8015C32C.o", "build/src/ov_SC02_003/ov_SC02_003_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018D25C[];\n    extern u8 D_8018D26C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018D298[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D25C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D26C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018D4DC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018D4DC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018D4DC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018D298[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018D25C[];\n    extern u8 D_8018D26C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018D298[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D25C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D26C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018D4DC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018D4DC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018D4DC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018D298[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:16", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_026/ov_SC02_026_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.298, "objects": ["build/src/ov_SC02_026/ov_SC02_026_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018877C[];\n    extern u8 D_8018878C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801887B8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018877C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018878C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801889FC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801889FC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801889FC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801887B8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018877C[];\n    extern u8 D_8018878C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801887B8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018877C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018878C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801889FC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801889FC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801889FC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801887B8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:16", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_039/ov_SC02_039_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.294, "objects": ["build/src/ov_SC02_039/ov_SC02_039_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018175C[];\n    extern u8 D_8018176C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80181798[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018175C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018176C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801819DC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801819DC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801819DC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181798[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018175C[];\n    extern u8 D_8018176C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80181798[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018175C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018176C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801819DC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801819DC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801819DC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181798[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:17", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_021/ov_SC02_021_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.301, "objects": ["build/src/ov_SC02_021/ov_SC02_021_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182128[];\n    extern u8 D_80182138[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80182164[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182128);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182138);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801823A8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801823A8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801823A8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80182164[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182128[];\n    extern u8 D_80182138[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80182164[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182128);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182138);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801823A8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801823A8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801823A8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80182164[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:17", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_027/ov_SC02_027_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.302, "objects": ["build/src/ov_SC02_027/ov_SC02_027_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018D8A0[];\n    extern u8 D_8018D8B0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018D8DC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D8A0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D8B0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018DB20[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018DB20[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018DB20[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018D8DC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018D8A0[];\n    extern u8 D_8018D8B0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018D8DC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D8A0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D8B0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018DB20[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018DB20[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018DB20[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018D8DC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:18", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_035/ov_SC02_035_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.295, "objects": ["build/src/ov_SC02_035/ov_SC02_035_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186B30[];\n    extern u8 D_80186B40[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80186B6C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186B30);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186B40);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186DB0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186DB0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186DB0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186B6C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186B30[];\n    extern u8 D_80186B40[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80186B6C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186B30);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186B40);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186DB0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186DB0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186DB0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186B6C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:18", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_031/ov_SC02_031_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.29, "objects": ["build/src/ov_SC02_031/ov_SC02_031_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801872D0[];\n    extern u8 D_801872E0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018730C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801872D0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801872E0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80187550[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80187550[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80187550[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018730C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801872D0[];\n    extern u8 D_801872E0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018730C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801872D0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801872E0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80187550[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80187550[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80187550[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018730C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:19", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_028/ov_SC02_028_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC02_028/ov_SC02_028_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018DAA4[];\n    extern u8 D_8018DAB4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018DAE0[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018DAA4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018DAB4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018DD24[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018DD24[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018DD24[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018DAE0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018DAA4[];\n    extern u8 D_8018DAB4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018DAE0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018DAA4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018DAB4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018DD24[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018DD24[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018DD24[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018DAE0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:19", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_003/ov_SC03_003_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.299, "objects": ["build/src/ov_SC03_003/ov_SC03_003_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181924[];\n    extern u8 D_80181934[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80181960[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181924);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181934);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80181BA4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80181BA4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80181BA4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181960[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181924[];\n    extern u8 D_80181934[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80181960[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181924);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181934);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80181BA4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80181BA4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80181BA4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181960[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:20", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_041/ov_SC02_041_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC02_041/ov_SC02_041_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018742C[];\n    extern u8 D_8018743C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80187468[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018742C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018743C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801876AC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801876AC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801876AC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80187468[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018742C[];\n    extern u8 D_8018743C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80187468[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018742C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018743C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801876AC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801876AC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801876AC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80187468[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:20", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_002/ov_SC03_002_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.294, "objects": ["build/src/ov_SC03_002/ov_SC03_002_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80187B5C[];\n    extern u8 D_80187B6C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80187B98[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187B5C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187B6C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80187DDC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80187DDC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80187DDC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80187B98[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80187B5C[];\n    extern u8 D_80187B6C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80187B98[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187B5C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187B6C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80187DDC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80187DDC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80187DDC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80187B98[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:21", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_012/ov_SC03_012_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC03_012/ov_SC03_012_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801807A8[];\n    extern u8 D_801807B8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801807E4[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801807A8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801807B8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180A28[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180A28[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180A28[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801807E4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801807A8[];\n    extern u8 D_801807B8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801807E4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801807A8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801807B8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180A28[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180A28[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180A28[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801807E4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:21", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_001/ov_SC03_001_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.297, "objects": ["build/src/ov_SC03_001/ov_SC03_001_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018FB6C[];\n    extern u8 D_8018FB7C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018FBA8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018FB6C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018FB7C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018FDEC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018FDEC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018FDEC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018FBA8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018FB6C[];\n    extern u8 D_8018FB7C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018FBA8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018FB6C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018FB7C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018FDEC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018FDEC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018FDEC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018FBA8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:21", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_007/ov_SC03_007_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.304, "objects": ["build/src/ov_SC03_007/ov_SC03_007_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80189A38[];\n    extern u8 D_80189A48[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80189A74[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189A38);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189A48);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80189CB8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80189CB8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80189CB8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80189A74[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80189A38[];\n    extern u8 D_80189A48[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80189A74[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189A38);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189A48);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80189CB8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80189CB8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80189CB8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80189A74[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:22", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_006/ov_SC03_006_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.295, "objects": ["build/src/ov_SC03_006/ov_SC03_006_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018EC40[];\n    extern u8 D_8018EC50[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018EC7C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018EC40);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018EC50);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018EEC0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018EEC0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018EEC0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018EC7C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018EC40[];\n    extern u8 D_8018EC50[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018EC7C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018EC40);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018EC50);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018EEC0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018EEC0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018EEC0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018EC7C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:22", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_011/ov_SC03_011_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.296, "objects": ["build/src/ov_SC03_011/ov_SC03_011_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801838C8[];\n    extern u8 D_801838D8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80183904[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801838C8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801838D8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183B48[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183B48[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183B48[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80183904[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801838C8[];\n    extern u8 D_801838D8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80183904[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801838C8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801838D8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183B48[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183B48[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183B48[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80183904[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:23", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_010/ov_SC03_010_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC03_010/ov_SC03_010_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182558[];\n    extern u8 D_80182568[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80182594[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182558);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182568);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801827D8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801827D8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801827D8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80182594[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182558[];\n    extern u8 D_80182568[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80182594[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182558);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182568);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801827D8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801827D8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801827D8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80182594[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:23", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_023/ov_SC03_023_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC03_023/ov_SC03_023_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181548[];\n    extern u8 D_80181558[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80181584[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181548);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181558);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801817C8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801817C8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801817C8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181584[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181548[];\n    extern u8 D_80181558[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80181584[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181548);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181558);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801817C8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801817C8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801817C8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181584[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:24", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_013/ov_SC03_013_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.296, "objects": ["build/src/ov_SC03_013/ov_SC03_013_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80183590[];\n    extern u8 D_801835A0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801835CC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183590);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801835A0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183810[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183810[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183810[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801835CC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80183590[];\n    extern u8 D_801835A0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801835CC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183590);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801835A0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183810[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183810[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183810[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801835CC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:24", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_028/ov_SC03_028_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.298, "objects": ["build/src/ov_SC03_028/ov_SC03_028_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018E038[];\n    extern u8 D_8018E048[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018E074[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018E038);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018E048);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018E2B8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018E2B8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018E2B8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018E074[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018E038[];\n    extern u8 D_8018E048[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018E074[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018E038);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018E048);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018E2B8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018E2B8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018E2B8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018E074[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:25", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_024/ov_SC03_024_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.29, "objects": ["build/src/ov_SC03_024/ov_SC03_024_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018956C[];\n    extern u8 D_8018957C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801895A8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018956C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018957C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801897EC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801897EC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801897EC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801895A8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018956C[];\n    extern u8 D_8018957C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801895A8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018956C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018957C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801897EC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801897EC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801897EC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801895A8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:25", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_014/ov_SC03_014_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.585, "objects": ["build/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.o", "build/src/ov_SC03_015/ov_SC03_015_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018DBCC[];\n    extern u8 D_8018DBDC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018DC08[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018DBCC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018DBDC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018DE4C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018DE4C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018DE4C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018DC08[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018DBCC[];\n    extern u8 D_8018DBDC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018DC08[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018DBCC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018DBDC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018DE4C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018DE4C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018DE4C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018DC08[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:26", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_031/ov_SC03_031_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC03_031/ov_SC03_031_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801849C8[];\n    extern u8 D_801849D8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80184A04[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801849C8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801849D8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184C48[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184C48[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184C48[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184A04[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801849C8[];\n    extern u8 D_801849D8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80184A04[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801849C8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801849D8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184C48[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184C48[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184C48[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184A04[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:26", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_089/ov_SC03_089_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.297, "objects": ["build/src/ov_SC03_089/ov_SC03_089_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018BCC4[];\n    extern u8 D_8018BCD4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018BD00[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018BCC4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018BCD4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018BF44[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018BF44[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018BF44[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018BD00[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018BCC4[];\n    extern u8 D_8018BCD4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018BD00[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018BCC4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018BCD4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018BF44[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018BF44[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018BF44[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018BD00[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:27", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_091/ov_SC03_091_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC03_091/ov_SC03_091_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018EF90[];\n    extern u8 D_8018EFA0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018EFCC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018EF90);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018EFA0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018F210[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018F210[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018F210[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018EFCC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018EF90[];\n    extern u8 D_8018EFA0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018EFCC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018EF90);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018EFA0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018F210[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018F210[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018F210[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018EFCC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:27", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_093/ov_SC03_093_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.289, "objects": ["build/src/ov_SC03_093/ov_SC03_093_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80188538[];\n    extern u8 D_80188548[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80188574[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188538);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188548);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801887B8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801887B8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801887B8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188574[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80188538[];\n    extern u8 D_80188548[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80188574[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188538);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188548);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801887B8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801887B8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801887B8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188574[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:28", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_090/ov_SC03_090_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC03_090/ov_SC03_090_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018E0E8[];\n    extern u8 D_8018E0F8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018E124[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018E0E8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018E0F8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018E368[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018E368[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018E368[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018E124[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018E0E8[];\n    extern u8 D_8018E0F8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018E124[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018E0E8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018E0F8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018E368[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018E368[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018E368[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018E124[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:28", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_030/ov_SC03_030_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC03_030/ov_SC03_030_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801844AC[];\n    extern u8 D_801844BC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801844E8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801844AC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801844BC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018472C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018472C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018472C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801844E8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801844AC[];\n    extern u8 D_801844BC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801844E8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801844AC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801844BC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018472C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018472C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018472C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801844E8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:29", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_097/ov_SC03_097_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC03_097/ov_SC03_097_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801884F4[];\n    extern u8 D_80188504[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80188530[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801884F4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188504);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80188774[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80188774[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80188774[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188530[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801884F4[];\n    extern u8 D_80188504[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80188530[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801884F4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188504);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80188774[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80188774[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80188774[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188530[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:29", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_029/ov_SC03_029_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC03_029/ov_SC03_029_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80189E70[];\n    extern u8 D_80189E80[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80189EAC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189E70);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189E80);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018A0F0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018A0F0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018A0F0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80189EAC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80189E70[];\n    extern u8 D_80189E80[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80189EAC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189E70);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189E80);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018A0F0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018A0F0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018A0F0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80189EAC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:29", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_094/ov_SC03_094_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC03_094/ov_SC03_094_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80189F34[];\n    extern u8 D_80189F44[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80189F70[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189F34);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189F44);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018A1B4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018A1B4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018A1B4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80189F70[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80189F34[];\n    extern u8 D_80189F44[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80189F70[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189F34);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189F44);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018A1B4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018A1B4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018A1B4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80189F70[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:30", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_095/ov_SC03_095_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC03_095/ov_SC03_095_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80183594[];\n    extern u8 D_801835A4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801835D0[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183594);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801835A4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183814[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183814[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183814[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801835D0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80183594[];\n    extern u8 D_801835A4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801835D0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183594);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801835A4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183814[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183814[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183814[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801835D0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:30", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_096/ov_SC03_096_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.294, "objects": ["build/src/ov_SC03_096/ov_SC03_096_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80183114[];\n    extern u8 D_80183124[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80183150[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183114);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183124);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183394[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183394[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183394[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80183150[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80183114[];\n    extern u8 D_80183124[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80183150[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183114);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183124);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183394[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183394[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183394[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80183150[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:31", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_092/ov_SC03_092_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.3, "objects": ["build/src/ov_SC03_092/ov_SC03_092_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80187360[];\n    extern u8 D_80187370[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018739C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187360);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187370);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801875E0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801875E0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801875E0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018739C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80187360[];\n    extern u8 D_80187370[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018739C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187360);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187370);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801875E0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801875E0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801875E0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018739C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:31", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_098/ov_SC03_098_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.303, "objects": ["build/src/ov_SC03_098/ov_SC03_098_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80187980[];\n    extern u8 D_80187990[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801879BC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187980);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187990);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80187C00[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80187C00[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80187C00[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801879BC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80187980[];\n    extern u8 D_80187990[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801879BC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187980);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187990);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80187C00[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80187C00[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80187C00[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801879BC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:32", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_100/ov_SC03_100_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC03_100/ov_SC03_100_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186F4C[];\n    extern u8 D_80186F5C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80186F88[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186F4C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186F5C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801871CC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801871CC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801871CC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186F88[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186F4C[];\n    extern u8 D_80186F5C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80186F88[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186F4C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186F5C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801871CC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801871CC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801871CC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186F88[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:32", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_099/ov_SC03_099_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.298, "objects": ["build/src/ov_SC03_099/ov_SC03_099_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80185A80[];\n    extern u8 D_80185A90[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80185ABC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185A80);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185A90);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185D00[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185D00[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185D00[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185ABC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80185A80[];\n    extern u8 D_80185A90[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80185ABC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185A80);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185A90);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185D00[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185D00[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185D00[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185ABC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:33", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_103/ov_SC03_103_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.297, "objects": ["build/src/ov_SC03_103/ov_SC03_103_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186790[];\n    extern u8 D_801867A0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801867CC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186790);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801867A0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186A10[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186A10[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186A10[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801867CC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186790[];\n    extern u8 D_801867A0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801867CC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186790);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801867A0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186A10[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186A10[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186A10[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801867CC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:33", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_101/ov_SC03_101_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC03_101/ov_SC03_101_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80185F28[];\n    extern u8 D_80185F38[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80185F64[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185F28);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185F38);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801861A8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801861A8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801861A8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185F64[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80185F28[];\n    extern u8 D_80185F38[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80185F64[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185F28);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185F38);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801861A8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801861A8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801861A8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185F64[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:34", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_102/ov_SC03_102_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.298, "objects": ["build/src/ov_SC03_102/ov_SC03_102_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801887E0[];\n    extern u8 D_801887F0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018881C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801887E0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801887F0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80188A60[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80188A60[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80188A60[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018881C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801887E0[];\n    extern u8 D_801887F0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018881C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801887E0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801887F0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80188A60[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80188A60[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80188A60[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018881C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:34", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_104/ov_SC03_104_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.297, "objects": ["build/src/ov_SC03_104/ov_SC03_104_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018D320[];\n    extern u8 D_8018D330[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018D35C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D320);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D330);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018D5A0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018D5A0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018D5A0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018D35C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018D320[];\n    extern u8 D_8018D330[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018D35C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D320);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D330);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018D5A0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018D5A0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018D5A0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018D35C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:35", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_111/ov_SC03_111_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC03_111/ov_SC03_111_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186F80[];\n    extern u8 D_80186F90[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80186FBC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186F80);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186F90);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80187200[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80187200[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80187200[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186FBC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186F80[];\n    extern u8 D_80186F90[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80186FBC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186F80);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186F90);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80187200[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80187200[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80187200[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186FBC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:35", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_108/ov_SC03_108_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.295, "objects": ["build/src/ov_SC03_108/ov_SC03_108_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80183300[];\n    extern u8 D_80183310[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018333C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183300);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183310);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183580[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183580[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183580[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018333C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80183300[];\n    extern u8 D_80183310[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018333C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183300);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183310);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183580[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183580[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183580[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018333C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:35", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_110/ov_SC03_110_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC03_110/ov_SC03_110_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801843CC[];\n    extern u8 D_801843DC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80184408[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801843CC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801843DC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018464C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018464C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018464C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184408[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801843CC[];\n    extern u8 D_801843DC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80184408[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801843CC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801843DC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018464C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018464C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018464C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184408[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:36", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_109/ov_SC03_109_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC03_109/ov_SC03_109_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801809AC[];\n    extern u8 D_801809BC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801809E8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801809AC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801809BC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180C2C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180C2C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180C2C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801809E8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801809AC[];\n    extern u8 D_801809BC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801809E8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801809AC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801809BC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180C2C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180C2C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180C2C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801809E8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:36", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_105/ov_SC03_105_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.296, "objects": ["build/src/ov_SC03_105/ov_SC03_105_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018C9A8[];\n    extern u8 D_8018C9B8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018C9E4[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018C9A8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018C9B8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018CC28[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018CC28[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018CC28[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018C9E4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018C9A8[];\n    extern u8 D_8018C9B8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018C9E4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018C9A8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018C9B8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018CC28[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018CC28[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018CC28[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018C9E4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:37", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_112/ov_SC03_112_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.295, "objects": ["build/src/ov_SC03_112/ov_SC03_112_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80187D88[];\n    extern u8 D_80187D98[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80187DC4[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187D88);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187D98);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80188008[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80188008[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80188008[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80187DC4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80187D88[];\n    extern u8 D_80187D98[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80187DC4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187D88);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187D98);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80188008[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80188008[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80188008[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80187DC4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:37", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_114/ov_SC03_114_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.301, "objects": ["build/src/ov_SC03_114/ov_SC03_114_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801810A0[];\n    extern u8 D_801810B0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801810DC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801810A0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801810B0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80181320[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80181320[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80181320[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801810DC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801810A0[];\n    extern u8 D_801810B0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801810DC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801810A0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801810B0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80181320[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80181320[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80181320[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801810DC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:38", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_115/ov_SC03_115_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.296, "objects": ["build/src/ov_SC03_115/ov_SC03_115_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182B0C[];\n    extern u8 D_80182B1C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80182B48[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182B0C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182B1C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80182D8C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80182D8C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80182D8C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80182B48[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182B0C[];\n    extern u8 D_80182B1C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80182B48[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182B0C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182B1C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80182D8C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80182D8C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80182D8C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80182B48[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:38", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_113/ov_SC03_113_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC03_113/ov_SC03_113_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80185438[];\n    extern u8 D_80185448[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80185474[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185438);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185448);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801856B8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801856B8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801856B8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185474[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80185438[];\n    extern u8 D_80185448[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80185474[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185438);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185448);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801856B8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801856B8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801856B8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185474[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:39", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_117/ov_SC03_117_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC03_117/ov_SC03_117_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186F1C[];\n    extern u8 D_80186F2C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80186F58[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186F1C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186F2C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018719C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018719C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018719C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186F58[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186F1C[];\n    extern u8 D_80186F2C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80186F58[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186F1C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186F2C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018719C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018719C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018719C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186F58[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:39", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_125/ov_SC03_125_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC03_125/ov_SC03_125_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801863E0[];\n    extern u8 D_801863F0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018641C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801863E0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801863F0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186660[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186660[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186660[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018641C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801863E0[];\n    extern u8 D_801863F0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018641C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801863E0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801863F0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186660[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186660[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186660[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018641C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:40", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_121/ov_SC03_121_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC03_121/ov_SC03_121_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801847E4[];\n    extern u8 D_801847F4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80184820[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801847E4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801847F4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184A64[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184A64[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184A64[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184820[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801847E4[];\n    extern u8 D_801847F4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80184820[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801847E4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801847F4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184A64[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184A64[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184A64[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184820[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:40", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_116/ov_SC03_116_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC03_116/ov_SC03_116_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80184F10[];\n    extern u8 D_80184F20[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80184F4C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184F10);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184F20);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185190[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185190[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185190[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184F4C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80184F10[];\n    extern u8 D_80184F20[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80184F4C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184F10);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184F20);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185190[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185190[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185190[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184F4C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:40", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_000/ov_SC04_000_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC04_000/ov_SC04_000_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801858E4[];\n    extern u8 D_801858F4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80185920[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801858E4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801858F4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185B64[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185B64[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185B64[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185920[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801858E4[];\n    extern u8 D_801858F4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80185920[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801858E4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801858F4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185B64[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185B64[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185B64[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185920[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:41", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_124/ov_SC03_124_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC03_124/ov_SC03_124_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018D210[];\n    extern u8 D_8018D220[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018D24C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D210);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D220);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018D490[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018D490[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018D490[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018D24C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018D210[];\n    extern u8 D_8018D220[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018D24C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D210);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018D220);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018D490[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018D490[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018D490[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018D24C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:41", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_002/ov_SC04_002_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.294, "objects": ["build/src/ov_SC04_002/ov_SC04_002_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018AA50[];\n    extern u8 D_8018AA60[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018AA8C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018AA50);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018AA60);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018ACD0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018ACD0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018ACD0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018AA8C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018AA50[];\n    extern u8 D_8018AA60[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018AA8C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018AA50);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018AA60);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018ACD0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018ACD0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018ACD0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018AA8C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:42", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_003/ov_SC04_003_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.29, "objects": ["build/src/ov_SC04_003/ov_SC04_003_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801847EC[];\n    extern u8 D_801847FC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80184828[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801847EC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801847FC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184A6C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184A6C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184A6C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184828[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801847EC[];\n    extern u8 D_801847FC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80184828[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801847EC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801847FC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184A6C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184A6C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184A6C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184828[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:43", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_118/ov_SC03_118_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.582, "objects": ["build/src/ov_SC03_118/ov_SC03_118_jr_8015C32C.o", "build/src/ov_SC03_119/ov_SC03_119_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018BFC8[];\n    extern u8 D_8018BFD8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018C004[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018BFC8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018BFD8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018C248[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018C248[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018C248[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018C004[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018BFC8[];\n    extern u8 D_8018BFD8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018C004[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018BFC8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018BFD8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018C248[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018C248[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018C248[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018C004[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:43", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_004/ov_SC04_004_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.29, "objects": ["build/src/ov_SC04_004/ov_SC04_004_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186D20[];\n    extern u8 D_80186D30[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80186D5C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186D20);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186D30);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186FA0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186FA0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186FA0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186D5C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186D20[];\n    extern u8 D_80186D30[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80186D5C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186D20);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186D30);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186FA0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186FA0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186FA0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186D5C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:43", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_009/ov_SC04_009_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC04_009/ov_SC04_009_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181150[];\n    extern u8 D_80181160[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018118C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181150);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181160);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801813D0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801813D0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801813D0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018118C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181150[];\n    extern u8 D_80181160[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018118C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181150);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181160);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801813D0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801813D0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801813D0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018118C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:44", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_005/ov_SC04_005_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.29, "objects": ["build/src/ov_SC04_005/ov_SC04_005_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018A154[];\n    extern u8 D_8018A164[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018A190[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018A154);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018A164);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018A3D4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018A3D4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018A3D4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018A190[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018A154[];\n    extern u8 D_8018A164[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018A190[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018A154);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018A164);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018A3D4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018A3D4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018A3D4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018A190[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:44", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_007/ov_SC04_007_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC04_007/ov_SC04_007_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801881EC[];\n    extern u8 D_801881FC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80188228[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801881EC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801881FC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018846C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018846C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018846C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188228[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801881EC[];\n    extern u8 D_801881FC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80188228[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801881EC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801881FC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018846C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018846C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018846C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188228[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:45", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_016/ov_SC04_016_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.297, "objects": ["build/src/ov_SC04_016/ov_SC04_016_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018265C[];\n    extern u8 D_8018266C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80182698[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018265C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018266C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801828DC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801828DC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801828DC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80182698[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018265C[];\n    extern u8 D_8018266C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80182698[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018265C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018266C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801828DC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801828DC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801828DC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80182698[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:45", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_012/ov_SC04_012_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.294, "objects": ["build/src/ov_SC04_012/ov_SC04_012_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80180C60[];\n    extern u8 D_80180C70[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80180C9C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180C60);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180C70);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180EE0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180EE0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180EE0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180C9C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80180C60[];\n    extern u8 D_80180C70[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80180C9C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180C60);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180C70);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180EE0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180EE0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180EE0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180C9C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:46", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_010/ov_SC04_010_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC04_010/ov_SC04_010_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801807FC[];\n    extern u8 D_8018080C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80180838[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801807FC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018080C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180A7C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180A7C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180A7C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180838[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801807FC[];\n    extern u8 D_8018080C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80180838[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801807FC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018080C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180A7C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180A7C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180A7C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180838[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:46", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_006/ov_SC04_006_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.298, "objects": ["build/src/ov_SC04_006/ov_SC04_006_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182234[];\n    extern u8 D_80182244[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80182270[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182234);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182244);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801824B4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801824B4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801824B4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80182270[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182234[];\n    extern u8 D_80182244[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80182270[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182234);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182244);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801824B4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801824B4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801824B4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80182270[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:47", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_015/ov_SC04_015_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.298, "objects": ["build/src/ov_SC04_015/ov_SC04_015_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186B98[];\n    extern u8 D_80186BA8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80186BD4[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186B98);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186BA8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186E18[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186E18[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186E18[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186BD4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80186B98[];\n    extern u8 D_80186BA8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80186BD4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186B98);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80186BA8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80186E18[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80186E18[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80186E18[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80186BD4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:47", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_020/ov_SC04_020_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.295, "objects": ["build/src/ov_SC04_020/ov_SC04_020_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801859AC[];\n    extern u8 D_801859BC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801859E8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801859AC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801859BC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185C2C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185C2C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185C2C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801859E8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801859AC[];\n    extern u8 D_801859BC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801859E8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801859AC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801859BC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185C2C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185C2C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185C2C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801859E8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:48", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_001/ov_SC05_001_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.289, "objects": ["build/src/ov_SC05_001/ov_SC05_001_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801880C8[];\n    extern u8 D_801880D8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80188104[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801880C8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801880D8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80188348[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80188348[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80188348[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188104[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801880C8[];\n    extern u8 D_801880D8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80188104[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801880C8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801880D8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80188348[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80188348[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80188348[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188104[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:48", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_000/ov_SC05_000_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC05_000/ov_SC05_000_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801808EC[];\n    extern u8 D_801808FC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80180928[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801808EC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801808FC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180B6C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180B6C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180B6C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180928[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801808EC[];\n    extern u8 D_801808FC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80180928[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801808EC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801808FC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180B6C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180B6C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180B6C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180928[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:48", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_006/ov_SC05_006_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC05_006/ov_SC05_006_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181AC0[];\n    extern u8 D_80181AD0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80181AFC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181AC0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181AD0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80181D40[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80181D40[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80181D40[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181AFC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181AC0[];\n    extern u8 D_80181AD0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80181AFC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181AC0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181AD0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80181D40[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80181D40[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80181D40[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181AFC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:49", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_007/ov_SC05_007_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC05_007/ov_SC05_007_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801830BC[];\n    extern u8 D_801830CC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801830F8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801830BC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801830CC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018333C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018333C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018333C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801830F8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801830BC[];\n    extern u8 D_801830CC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801830F8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801830BC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801830CC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018333C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018333C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018333C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801830F8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:49", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_010/ov_SC05_010_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC05_010/ov_SC05_010_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018B000[];\n    extern u8 D_8018B010[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018B03C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018B000);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018B010);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018B280[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018B280[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018B280[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018B03C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018B000[];\n    extern u8 D_8018B010[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018B03C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018B000);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018B010);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018B280[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018B280[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018B280[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018B03C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:50", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_005/ov_SC05_005_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC05_005/ov_SC05_005_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80184AA0[];\n    extern u8 D_80184AB0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80184ADC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184AA0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184AB0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184D20[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184D20[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184D20[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184ADC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80184AA0[];\n    extern u8 D_80184AB0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80184ADC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184AA0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184AB0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184D20[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184D20[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184D20[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184ADC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:50", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_002/ov_SC05_002_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC05_002/ov_SC05_002_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182888[];\n    extern u8 D_80182898[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801828C4[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182888);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182898);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80182B08[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80182B08[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80182B08[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801828C4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182888[];\n    extern u8 D_80182898[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801828C4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182888);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182898);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80182B08[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80182B08[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80182B08[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801828C4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:51", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_018/ov_SC04_018_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.583, "objects": ["build/src/ov_SC04_018/ov_SC04_018_jr_8015C32C.o", "build/src/ov_SC04_019/ov_SC04_019_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018F874[];\n    extern u8 D_8018F884[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018F8B0[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018F874);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018F884);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018FAF4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018FAF4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018FAF4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018F8B0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018F874[];\n    extern u8 D_8018F884[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018F8B0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018F874);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018F884);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018FAF4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018FAF4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018FAF4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018F8B0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:51", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_008/ov_SC05_008_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.289, "objects": ["build/src/ov_SC05_008/ov_SC05_008_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80185014[];\n    extern u8 D_80185024[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80185050[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185014);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185024);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185294[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185294[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185294[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185050[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80185014[];\n    extern u8 D_80185024[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80185050[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185014);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80185024);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80185294[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80185294[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80185294[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80185050[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:52", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_003/ov_SC05_003_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC05_003/ov_SC05_003_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80184BC0[];\n    extern u8 D_80184BD0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80184BFC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184BC0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184BD0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184E40[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184E40[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184E40[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184BFC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80184BC0[];\n    extern u8 D_80184BD0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80184BFC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184BC0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184BD0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184E40[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184E40[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184E40[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184BFC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:52", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_004/ov_SC05_004_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.302, "objects": ["build/src/ov_SC05_004/ov_SC05_004_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80183CCC[];\n    extern u8 D_80183CDC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80183D08[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183CCC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183CDC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183F4C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183F4C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183F4C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80183D08[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80183CCC[];\n    extern u8 D_80183CDC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80183D08[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183CCC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183CDC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183F4C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183F4C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183F4C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80183D08[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:53", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_011/ov_SC05_011_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.295, "objects": ["build/src/ov_SC05_011/ov_SC05_011_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80180378[];\n    extern u8 D_80180388[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801803B4[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180378);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180388);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801805F8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801805F8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801805F8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801803B4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80180378[];\n    extern u8 D_80180388[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801803B4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180378);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180388);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801805F8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801805F8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801805F8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801803B4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:53", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_017/ov_SC05_017_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC05_017/ov_SC05_017_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018F838[];\n    extern u8 D_8018F848[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018F874[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018F838);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018F848);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018FAB8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018FAB8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018FAB8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018F874[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018F838[];\n    extern u8 D_8018F848[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018F874[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018F838);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018F848);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018FAB8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018FAB8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018FAB8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018F874[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:54", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_018/ov_SC05_018_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.295, "objects": ["build/src/ov_SC05_018/ov_SC05_018_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80188F94[];\n    extern u8 D_80188FA4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80188FD0[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188F94);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188FA4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80189214[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80189214[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80189214[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188FD0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80188F94[];\n    extern u8 D_80188FA4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80188FD0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188F94);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188FA4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80189214[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80189214[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80189214[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188FD0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:54", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_006/ov_SC06_006_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.296, "objects": ["build/src/ov_SC06_006/ov_SC06_006_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018440C[];\n    extern u8 D_8018441C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80184448[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018440C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018441C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018468C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018468C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018468C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184448[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018440C[];\n    extern u8 D_8018441C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80184448[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018440C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018441C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018468C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018468C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018468C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184448[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:55", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_000/ov_SC06_000_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.29, "objects": ["build/src/ov_SC06_000/ov_SC06_000_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018A8E8[];\n    extern u8 D_8018A8F8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018A924[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018A8E8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018A8F8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018AB68[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018AB68[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018AB68[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018A924[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018A8E8[];\n    extern u8 D_8018A8F8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018A924[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018A8E8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018A8F8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018AB68[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018AB68[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018AB68[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018A924[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:55", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_010/ov_SC06_010_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.297, "objects": ["build/src/ov_SC06_010/ov_SC06_010_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80189050[];\n    extern u8 D_80189060[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018908C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189050);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189060);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801892D0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801892D0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801892D0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018908C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80189050[];\n    extern u8 D_80189060[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018908C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189050);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80189060);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801892D0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801892D0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801892D0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018908C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:56", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_008/ov_SC06_008_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.311, "objects": ["build/src/ov_SC06_008/ov_SC06_008_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80187E74[];\n    extern u8 D_80187E84[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80187EB0[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187E74);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187E84);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801880F4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801880F4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801880F4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80187EB0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80187E74[];\n    extern u8 D_80187E84[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80187EB0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187E74);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187E84);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801880F4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801880F4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801880F4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80187EB0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:56", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_016/ov_SC06_016_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.287, "objects": ["build/src/ov_SC06_016/ov_SC06_016_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801874F8[];\n    extern u8 D_80187508[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80187534[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801874F8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187508);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80187778[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80187778[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80187778[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80187534[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801874F8[];\n    extern u8 D_80187508[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80187534[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801874F8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187508);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80187778[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80187778[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80187778[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80187534[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:57", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_013/ov_SC06_013_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.294, "objects": ["build/src/ov_SC06_013/ov_SC06_013_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018122C[];\n    extern u8 D_8018123C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80181268[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018122C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018123C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801814AC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801814AC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801814AC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181268[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018122C[];\n    extern u8 D_8018123C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80181268[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018122C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018123C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801814AC[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801814AC[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801814AC[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181268[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:57", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_014/ov_SC06_014_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC06_014/ov_SC06_014_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182590[];\n    extern u8 D_801825A0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801825CC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182590);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801825A0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80182810[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80182810[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80182810[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801825CC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182590[];\n    extern u8 D_801825A0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801825CC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182590);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801825A0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80182810[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80182810[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80182810[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801825CC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:57", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_011/ov_SC06_011_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC06_011/ov_SC06_011_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182AB0[];\n    extern u8 D_80182AC0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80182AEC[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182AB0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182AC0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80182D30[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80182D30[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80182D30[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80182AEC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80182AB0[];\n    extern u8 D_80182AC0[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80182AEC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182AB0);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80182AC0);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80182D30[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80182D30[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80182D30[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80182AEC[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:58", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_015/ov_SC06_015_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC06_015/ov_SC06_015_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801810E8[];\n    extern u8 D_801810F8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80181124[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801810E8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801810F8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80181368[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80181368[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80181368[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181124[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801810E8[];\n    extern u8 D_801810F8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80181124[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801810E8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801810F8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80181368[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80181368[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80181368[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181124[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:58", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_018/ov_SC06_018_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC06_018/ov_SC06_018_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80195C34[];\n    extern u8 D_80195C44[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80195C70[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80195C34);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80195C44);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80195EB4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80195EB4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80195EB4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80195C70[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80195C34[];\n    extern u8 D_80195C44[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80195C70[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80195C34);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80195C44);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80195EB4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80195EB4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80195EB4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80195C70[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:59", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_020/ov_SC06_020_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.29, "objects": ["build/src/ov_SC06_020/ov_SC06_020_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801876BC[];\n    extern u8 D_801876CC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801876F8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801876BC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801876CC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018793C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018793C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018793C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801876F8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801876BC[];\n    extern u8 D_801876CC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801876F8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801876BC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801876CC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018793C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018793C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018793C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801876F8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:47:59", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_000/ov_SC07_000_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC07_000/ov_SC07_000_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80184CDC[];\n    extern u8 D_80184CEC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80184D18[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184CDC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184CEC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184F5C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184F5C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184F5C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184D18[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80184CDC[];\n    extern u8 D_80184CEC[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80184D18[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184CDC);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80184CEC);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184F5C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184F5C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184F5C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80184D18[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:00", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_027/ov_SC06_027_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.295, "objects": ["build/src/ov_SC06_027/ov_SC06_027_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80180634[];\n    extern u8 D_80180644[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80180670[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180634);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180644);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801808B4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801808B4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801808B4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180670[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80180634[];\n    extern u8 D_80180644[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80180670[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180634);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180644);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801808B4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801808B4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801808B4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180670[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:00", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_024/ov_SC06_024_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC06_024/ov_SC06_024_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80191E50[];\n    extern u8 D_80191E60[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80191E8C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80191E50);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80191E60);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801920D0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801920D0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801920D0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80191E8C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80191E50[];\n    extern u8 D_80191E60[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80191E8C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80191E50);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80191E60);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801920D0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801920D0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801920D0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80191E8C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:01", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_029/ov_SC06_029_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.291, "objects": ["build/src/ov_SC06_029/ov_SC06_029_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018EBC8[];\n    extern u8 D_8018EBD8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018EC04[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018EBC8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018EBD8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018EE48[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018EE48[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018EE48[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018EC04[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018EBC8[];\n    extern u8 D_8018EBD8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018EC04[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018EBC8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018EBD8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018EE48[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018EE48[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018EE48[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018EC04[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:01", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_030/ov_SC06_030_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.289, "objects": ["build/src/ov_SC06_030/ov_SC06_030_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801844B8[];\n    extern u8 D_801844C8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801844F4[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801844B8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801844C8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184738[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184738[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184738[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801844F4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801844B8[];\n    extern u8 D_801844C8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801844F4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801844B8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801844C8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80184738[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80184738[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80184738[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801844F4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:02", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_032/ov_SC06_032_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.293, "objects": ["build/src/ov_SC06_032/ov_SC06_032_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80195984[];\n    extern u8 D_80195994[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_801959C0[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80195984);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80195994);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80195C04[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80195C04[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80195C04[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801959C0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80195984[];\n    extern u8 D_80195994[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_801959C0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80195984);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80195994);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80195C04[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80195C04[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80195C04[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_801959C0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:02", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_033/ov_SC06_033_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.29, "objects": ["build/src/ov_SC06_033/ov_SC06_033_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80193E94[];\n    extern u8 D_80193EA4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80193ED0[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80193E94);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80193EA4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80194114[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80194114[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80194114[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80193ED0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80193E94[];\n    extern u8 D_80193EA4[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80193ED0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80193E94);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80193EA4);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80194114[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80194114[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80194114[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80193ED0[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:02", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_025/ov_SC06_025_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.288, "objects": ["build/src/ov_SC06_025/ov_SC06_025_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801872F4[];\n    extern u8 D_80187304[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80187330[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801872F4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187304);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80187574[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80187574[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80187574[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80187330[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801872F4[];\n    extern u8 D_80187304[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80187330[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801872F4);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80187304);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80187574[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80187574[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80187574[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80187330[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:03", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_022/ov_SC06_022_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC06_022/ov_SC06_022_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018F978[];\n    extern u8 D_8018F988[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8018F9B4[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018F978);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018F988);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018FBF8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018FBF8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018FBF8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018F9B4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8018F978[];\n    extern u8 D_8018F988[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8018F9B4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018F978);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8018F988);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8018FBF8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8018FBF8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8018FBF8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8018F9B4[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:03", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_001/ov_SC07_001_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.289, "objects": ["build/src/ov_SC07_001/ov_SC07_001_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80183B8C[];\n    extern u8 D_80183B9C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80183BC8[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183B8C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183B9C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183E0C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183E0C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183E0C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80183BC8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80183B8C[];\n    extern u8 D_80183B9C[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80183BC8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183B8C);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80183B9C);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80183E0C[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80183E0C[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80183E0C[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80183BC8[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:04", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_002/ov_SC07_002_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.289, "objects": ["build/src/ov_SC07_002/ov_SC07_002_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80188E48[];\n    extern u8 D_80188E58[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80188E84[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188E48);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188E58);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801890C8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801890C8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801890C8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188E84[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80188E48[];\n    extern u8 D_80188E58[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80188E84[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188E48);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80188E58);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801890C8[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801890C8[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801890C8[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80188E84[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:04", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_008/ov_SC07_008_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.292, "objects": ["build/src/ov_SC07_008/ov_SC07_008_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8017F960[];\n    extern u8 D_8017F970[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_8017F99C[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8017F960);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8017F970);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8017FBE0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8017FBE0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8017FBE0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8017F99C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_8017F960[];\n    extern u8 D_8017F970[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_8017F99C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8017F960);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_8017F970);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_8017FBE0[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_8017FBE0[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_8017FBE0[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_8017F99C[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:05", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_009/ov_SC07_009_jr_8015C32C.c", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": false, "includers": 0, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.29, "objects": ["build/src/ov_SC07_009/ov_SC07_009_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80180404[];\n    extern u8 D_80180414[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80180440[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180404);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180414);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180684[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180684[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180684[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180440[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80180404[];\n    extern u8 D_80180414[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80180440[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180404);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80180414);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80180684[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80180684[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80180684[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80180440[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:06", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/shared/ov/func_8015D738__6e729a10.h", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": true, "includers": 3, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 3, "seconds": 0.869, "objects": ["build/src/ov_SC03_126/ov_SC03_126_jr_8015C32C.o", "build/src/ov_SC04_021/ov_SC04_021_jr_8015C32C.o", "build/src/ov_SC05_019/ov_SC05_019_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801818D8[];\n    extern u8 D_801818E8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B headers2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80181914[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801818D8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801818E8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80181B58[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80181B58[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80181B58[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181914[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_801818D8[];\n    extern u8 D_801818E8[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80181914[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801818D8);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_801818E8);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_80181B58[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_80181B58[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_80181B58[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181914[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:06", "label": "c5p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/shared/ov/func_8015D738__d338deef.h", "fn": "func_8015D738", "addr": 2148915000, "aliases": null, "header": true, "includers": 2, "nhash_before": "5023cb215c7706fa2641b5a50218760088682e22", "nhash_after": "d0805606a044d30ef513f6d242fbfec32c0531e5", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c:func_8015D738", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.576, "objects": ["build/src/ov_SC04_008/ov_SC04_008_jr_8015C32C.o", "build/src/ov_SC05_009/ov_SC05_009_jr_8015C32C.o"], "before_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181124[];\n    extern u8 D_80181134[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 != 0) {\n        if (*(u16 *)s1 == 0x360) goto block_808;\n    }\n    __asm__ __volatile__(\"\");  // !FAKE: barrier \u2014 NEEDED DIFFERS (P36 rung B headers2)\n    if (s1 != 0) {\n        if (*(u16 *)s1 != 0) goto block_7F4;\n    }\n    D_80181160[*(u16 *)arg0](arg0);\n    ((void (*)(void *, s32))func_80147078)(arg0, 0);\n    func_80159B70(arg0);\n    return;\nblock_7F4:\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181124);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181134);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801813A4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801813A4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801813A4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181160[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n", "after_text": "void func_8015D738(void *arg0) {\n\n    extern u8 D_80181124[];\n    extern u8 D_80181134[];\n    u8 *p = D_80078E78;\n    s32 s1;\n    ((void (*)(void))func_80148AFC)();\n    if (func_80161B18(arg0) != 0) return;\n    if (func_80161B84(arg0) != 0) return;\n    do {\n        s1 = *(s32 *)((char *)arg0 + 0x178);\n    } while (0);\n    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    if (s1 == 0 || *(u16 *)s1 == 0) {\n        D_80181160[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 0);\n        func_80159B70(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {\n    block_808:\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DAC4)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x10) && ((s32 (*)(void *))func_8014BEF8)(arg0) != 0) {\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        ((void (*)(void *))func_8015DE24)(arg0);\n        return;\n    }\n    if ((((s32 (*)(void *))func_80148800)(arg0) & 0x20) && p[0x49] == 0xA) {\n        if (((s32 (*)(void *))func_80165624)(arg0) != 0) {\n            ((void (*)(void *))func_8015DA5C)(arg0);\n            ((void (*)(void *))func_8015F948)(arg0);\n            return;\n        }\n        ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);\n        func_800CAF14(arg0);\n        return;\n    }\n    if (((s32 (*)(void *))func_801488A8)(arg0) != 0 && *(u16 *)(*(s32 *)((char *)arg0 + 0x178)) != 0x82) {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1B);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181124);\n    } else {\n        ((void (*)(void *, s32))func_80154150)(arg0, 0x1A);\n        ((void (*)(void *, void *))func_80146DB8)(arg0, &D_80181134);\n    }\n    ((void (*)(void *))func_80147A84)(arg0);\n    ((void (*)(void *))func_801473EC)(arg0);\n    s1 = *(s32 *)((char *)arg0 + 0x178);\n    *(s16 *)(s1 + 6) = (s16)((s8)D_801813A4[*(s32 *)((char *)arg0 + 0x234)] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xc));\n    *(s16 *)(s1 + 0xa) = (s16)((s8)D_801813A4[*(s32 *)((char *)arg0 + 0x234) + 1] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0xe));\n    *(s16 *)(s1 + 0xe) = (s16)((s8)D_801813A4[*(s32 *)((char *)arg0 + 0x234) + 2] + *(u16 *)(*(s32 *)(s1 + 0x78) + 0x10));\n    ((void (*)(void *, void *))func_80149374)(arg0, (void *)(s1 + 4));\n    *(s16 *)(*(s32 *)(s1 + 0x20) + 0x12) = (*(u16 *)(*(s32 *)((char *)arg0 + 0x20) + 0x12) + 0x800) & 0xFFF;\n    if (((s32 (*)(void *))func_8014D738)(arg0) != 0) {\n        D_80181160[*(u16 *)arg0](arg0);\n        ((void (*)(void *, s32))func_80147078)(arg0, 9);\n        func_8015C714(arg0);\n        return;\n    }\n    if (func_80161208(arg0) != 0) return;\n    ((void (*)(void *))func_801483E8)(arg0);\n}\n"}
+{"ts": "2026-09-10 14:48:07", "label": "c8", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "T7 agent c8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801909C0;\n    extern s16 * D_801909BC;\n    extern u8 D_801909C8;\n    extern s16 *D_801909C4;\n    extern u16 D_801EDA40;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801909C0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801909BC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801909C8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801909C0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801909BC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EDA30;\n    D_801EDA40 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801909C4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801EDA40;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801909BC -> $a0 (reloaded) */\n        int qa0;   /* D_801909C0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801909C0 -> $a2 (reloaded) */\n        qb = (u16 *)D_801909BC;\n        qa = (u16 *)D_801909C0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801EDA30))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801909C0;\n    extern s16 * D_801909BC;\n    extern u8 D_801909C8;\n    extern s16 *D_801909C4;\n    extern u16 D_801EDA40;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801909C0;\n\n    ax = ((u16 *)p2)[0]; pac = D_801909BC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801EDA40 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801EDA30)) {\n    found:\n        pb4 = (*(u16 * *)&D_801909C4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801EDA40;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801909BC -> $a0 (reloaded) */\n        int qa0;   /* D_801909C0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801909C0 -> $a2 (reloaded) */\n        qb = (u16 *)D_801909BC;\n        qa = (u16 *)D_801909C0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801EDA30))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:08", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_077/ov_SC01_077_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC01_077/ov_SC01_077_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801870B0;\n    extern s16 * D_801870AC;\n    extern u8 D_801870B8;\n    extern s16 *D_801870B4;\n    extern u16 D_801D9500;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801870B0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801870AC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801870B8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801870B0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801870AC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801870B8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D94F0;\n    D_801D9500 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801870B4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D9500;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801870AC -> $a0 (reloaded) */\n        int qa0;   /* D_801870B0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801870B0 -> $a2 (reloaded) */\n        qb = (u16 *)D_801870AC;\n        qa = (u16 *)D_801870B0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D94F0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801870B0;\n    extern s16 * D_801870AC;\n    extern u8 D_801870B8;\n    extern s16 *D_801870B4;\n    extern u16 D_801D9500;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801870B0;\n\n    ax = ((u16 *)p2)[0]; pac = D_801870AC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801870B8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801D9500 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801D94F0)) {\n    found:\n        pb4 = (*(u16 * *)&D_801870B4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D9500;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801870AC -> $a0 (reloaded) */\n        int qa0;   /* D_801870B0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801870B0 -> $a2 (reloaded) */\n        qb = (u16 *)D_801870AC;\n        qa = (u16 *)D_801870B0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D94F0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:09", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017FD24;\n    extern s16 * D_8017FD20;\n    extern u8 D_8017FD2C;\n    extern s16 *D_8017FD28;\n    extern u16 D_801A2060;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017FD24 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017FD20 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017FD2C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017FD24;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017FD20; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017FD2C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A2050;\n    D_801A2060 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017FD28);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A2060;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017FD20 -> $a0 (reloaded) */\n        int qa0;   /* D_8017FD24[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017FD24 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017FD20;\n        qa = (u16 *)D_8017FD24;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A2050))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017FD24;\n    extern s16 * D_8017FD20;\n    extern u8 D_8017FD2C;\n    extern s16 *D_8017FD28;\n    extern u16 D_801A2060;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017FD24;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017FD20; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017FD2C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A2060 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A2050)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017FD28);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A2060;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017FD20 -> $a0 (reloaded) */\n        int qa0;   /* D_8017FD24[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017FD24 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017FD20;\n        qa = (u16 *)D_8017FD24;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A2050))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:09", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017EB8C;\n    extern s16 * D_8017EB88;\n    extern u8 D_8017EB94;\n    extern s16 *D_8017EB90;\n    extern u16 D_8019A940;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017EB8C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017EB88 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017EB94 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017EB8C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017EB88; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017EB94); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019A930;\n    D_8019A940 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017EB90);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019A940;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017EB88 -> $a0 (reloaded) */\n        int qa0;   /* D_8017EB8C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017EB8C -> $a2 (reloaded) */\n        qb = (u16 *)D_8017EB88;\n        qa = (u16 *)D_8017EB8C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019A930))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017EB8C;\n    extern s16 * D_8017EB88;\n    extern u8 D_8017EB94;\n    extern s16 *D_8017EB90;\n    extern u16 D_8019A940;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017EB8C;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017EB88; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017EB94); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019A940 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019A930)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017EB90);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019A940;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017EB88 -> $a0 (reloaded) */\n        int qa0;   /* D_8017EB8C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017EB8C -> $a2 (reloaded) */\n        qb = (u16 *)D_8017EB88;\n        qa = (u16 *)D_8017EB8C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019A930))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:09", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F19C;\n    extern s16 * D_8017F198;\n    extern u8 D_8017F1A4;\n    extern s16 *D_8017F1A0;\n    extern u16 D_801A4458;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017F19C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017F198 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017F1A4 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017F19C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017F198; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F1A4); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A4448;\n    D_801A4458 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F1A0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A4458;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F198 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F19C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F19C -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F198;\n        qa = (u16 *)D_8017F19C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A4448))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F19C;\n    extern s16 * D_8017F198;\n    extern u8 D_8017F1A4;\n    extern s16 *D_8017F1A0;\n    extern u16 D_801A4458;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017F19C;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017F198; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F1A4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A4458 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A4448)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F1A0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A4458;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F198 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F19C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F19C -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F198;\n        qa = (u16 *)D_8017F19C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A4448))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:10", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182F0C;\n    extern s16 * D_80182F08;\n    extern u8 D_80182F14;\n    extern s16 *D_80182F10;\n    extern u16 D_801F1EC0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80182F0C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80182F08 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80182F14 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80182F0C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80182F08; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182F14); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801F1EB0;\n    D_801F1EC0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182F10);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801F1EC0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182F08 -> $a0 (reloaded) */\n        int qa0;   /* D_80182F0C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182F0C -> $a2 (reloaded) */\n        qb = (u16 *)D_80182F08;\n        qa = (u16 *)D_80182F0C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801F1EB0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182F0C;\n    extern s16 * D_80182F08;\n    extern u8 D_80182F14;\n    extern s16 *D_80182F10;\n    extern u16 D_801F1EC0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80182F0C;\n\n    ax = ((u16 *)p2)[0]; pac = D_80182F08; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182F14); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801F1EC0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801F1EB0)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182F10);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801F1EC0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182F08 -> $a0 (reloaded) */\n        int qa0;   /* D_80182F0C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182F0C -> $a2 (reloaded) */\n        qb = (u16 *)D_80182F08;\n        qa = (u16 *)D_80182F0C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801F1EB0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:10", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80183DEC;\n    extern s16 * D_80183DE8;\n    extern u8 D_80183DF4;\n    extern s16 *D_80183DF0;\n    extern u16 D_801EC6E8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80183DEC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80183DE8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80183DF4 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80183DEC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80183DE8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183DF4); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EC6D8;\n    D_801EC6E8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80183DF0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801EC6E8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80183DE8 -> $a0 (reloaded) */\n        int qa0;   /* D_80183DEC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80183DEC -> $a2 (reloaded) */\n        qb = (u16 *)D_80183DE8;\n        qa = (u16 *)D_80183DEC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801EC6D8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80183DEC;\n    extern s16 * D_80183DE8;\n    extern u8 D_80183DF4;\n    extern s16 *D_80183DF0;\n    extern u16 D_801EC6E8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80183DEC;\n\n    ax = ((u16 *)p2)[0]; pac = D_80183DE8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183DF4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801EC6E8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801EC6D8)) {\n    found:\n        pb4 = (*(u16 * *)&D_80183DF0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801EC6E8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80183DE8 -> $a0 (reloaded) */\n        int qa0;   /* D_80183DEC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80183DEC -> $a2 (reloaded) */\n        qb = (u16 *)D_80183DE8;\n        qa = (u16 *)D_80183DEC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801EC6D8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:10", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80190E74;\n    extern s16 * D_80190E70;\n    extern u8 D_80190E7C;\n    extern s16 *D_80190E78;\n    extern u16 D_801E3010;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80190E74 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80190E70 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80190E7C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80190E74;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80190E70; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80190E7C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E3000;\n    D_801E3010 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80190E78);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E3010;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80190E70 -> $a0 (reloaded) */\n        int qa0;   /* D_80190E74[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80190E74 -> $a2 (reloaded) */\n        qb = (u16 *)D_80190E70;\n        qa = (u16 *)D_80190E74;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E3000))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80190E74;\n    extern s16 * D_80190E70;\n    extern u8 D_80190E7C;\n    extern s16 *D_80190E78;\n    extern u16 D_801E3010;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80190E74;\n\n    ax = ((u16 *)p2)[0]; pac = D_80190E70; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80190E7C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801E3010 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801E3000)) {\n    found:\n        pb4 = (*(u16 * *)&D_80190E78);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E3010;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80190E70 -> $a0 (reloaded) */\n        int qa0;   /* D_80190E74[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80190E74 -> $a2 (reloaded) */\n        qb = (u16 *)D_80190E70;\n        qa = (u16 *)D_80190E74;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E3000))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:11", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E270;\n    extern s16 * D_8017E26C;\n    extern u8 D_8017E278;\n    extern s16 *D_8017E274;\n    extern u16 D_80194F98;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017E270 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017E26C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017E278 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017E270;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017E26C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E278); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80194F88;\n    D_80194F98 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E274);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80194F98;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E26C -> $a0 (reloaded) */\n        int qa0;   /* D_8017E270[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E270 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E26C;\n        qa = (u16 *)D_8017E270;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80194F88))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E270;\n    extern s16 * D_8017E26C;\n    extern u8 D_8017E278;\n    extern s16 *D_8017E274;\n    extern u16 D_80194F98;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017E270;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017E26C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E278); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_80194F98 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80194F88)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E274);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80194F98;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E26C -> $a0 (reloaded) */\n        int qa0;   /* D_8017E270[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E270 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E26C;\n        qa = (u16 *)D_8017E270;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80194F88))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:11", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80183AEC;\n    extern s16 * D_80183AE8;\n    extern u8 D_80183AF4;\n    extern s16 *D_80183AF0;\n    extern u16 D_801C4770;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80183AEC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80183AE8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80183AF4 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80183AEC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80183AE8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183AF4); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C4760;\n    D_801C4770 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80183AF0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C4770;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80183AE8 -> $a0 (reloaded) */\n        int qa0;   /* D_80183AEC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80183AEC -> $a2 (reloaded) */\n        qb = (u16 *)D_80183AE8;\n        qa = (u16 *)D_80183AEC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C4760))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80183AEC;\n    extern s16 * D_80183AE8;\n    extern u8 D_80183AF4;\n    extern s16 *D_80183AF0;\n    extern u16 D_801C4770;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80183AEC;\n\n    ax = ((u16 *)p2)[0]; pac = D_80183AE8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183AF4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801C4770 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801C4760)) {\n    found:\n        pb4 = (*(u16 * *)&D_80183AF0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C4770;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80183AE8 -> $a0 (reloaded) */\n        int qa0;   /* D_80183AEC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80183AEC -> $a2 (reloaded) */\n        qb = (u16 *)D_80183AE8;\n        qa = (u16 *)D_80183AEC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C4760))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:11", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F7B0;\n    extern s16 * D_8017F7AC;\n    extern u8 D_8017F7B8;\n    extern s16 *D_8017F7B4;\n    extern u16 D_8018EE50;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017F7B0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017F7AC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017F7B8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017F7B0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017F7AC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F7B8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018EE40;\n    D_8018EE50 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F7B4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8018EE50;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F7AC -> $a0 (reloaded) */\n        int qa0;   /* D_8017F7B0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F7B0 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F7AC;\n        qa = (u16 *)D_8017F7B0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8018EE40))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F7B0;\n    extern s16 * D_8017F7AC;\n    extern u8 D_8017F7B8;\n    extern s16 *D_8017F7B4;\n    extern u16 D_8018EE50;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017F7B0;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017F7AC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F7B8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8018EE50 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8018EE40)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F7B4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8018EE50;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F7AC -> $a0 (reloaded) */\n        int qa0;   /* D_8017F7B0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F7B0 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F7AC;\n        qa = (u16 *)D_8017F7B0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8018EE40))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:12", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186DE0;\n    extern s16 * D_80186DDC;\n    extern u8 D_80186DE8;\n    extern s16 *D_80186DE4;\n    extern u16 D_801C6218;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80186DE0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80186DDC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80186DE8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80186DE0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80186DDC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186DE8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C6208;\n    D_801C6218 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186DE4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C6218;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186DDC -> $a0 (reloaded) */\n        int qa0;   /* D_80186DE0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186DE0 -> $a2 (reloaded) */\n        qb = (u16 *)D_80186DDC;\n        qa = (u16 *)D_80186DE0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C6208))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186DE0;\n    extern s16 * D_80186DDC;\n    extern u8 D_80186DE8;\n    extern s16 *D_80186DE4;\n    extern u16 D_801C6218;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80186DE0;\n\n    ax = ((u16 *)p2)[0]; pac = D_80186DDC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186DE8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801C6218 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801C6208)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186DE4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C6218;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186DDC -> $a0 (reloaded) */\n        int qa0;   /* D_80186DE0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186DE0 -> $a2 (reloaded) */\n        qb = (u16 *)D_80186DDC;\n        qa = (u16 *)D_80186DE0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C6208))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:12", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801912C4;\n    extern s16 * D_801912C0;\n    extern u8 D_801912CC;\n    extern s16 *D_801912C8;\n    extern u16 D_801E9EF0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801912C4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801912C0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801912CC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801912C4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801912C0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801912CC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E9EE0;\n    D_801E9EF0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801912C8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E9EF0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801912C0 -> $a0 (reloaded) */\n        int qa0;   /* D_801912C4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801912C4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801912C0;\n        qa = (u16 *)D_801912C4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E9EE0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801912C4;\n    extern s16 * D_801912C0;\n    extern u8 D_801912CC;\n    extern s16 *D_801912C8;\n    extern u16 D_801E9EF0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801912C4;\n\n    ax = ((u16 *)p2)[0]; pac = D_801912C0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801912CC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801E9EF0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801E9EE0)) {\n    found:\n        pb4 = (*(u16 * *)&D_801912C8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E9EF0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801912C0 -> $a0 (reloaded) */\n        int qa0;   /* D_801912C4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801912C4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801912C0;\n        qa = (u16 *)D_801912C4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E9EE0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:12", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.466, "objects": ["build/src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.o", "build/src/ov_SC01_006/ov_SC01_006_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182944;\n    extern s16 * D_80182940;\n    extern u8 D_8018294C;\n    extern s16 *D_80182948;\n    extern u16 D_801CC5B0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80182944 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80182940 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018294C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80182944;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80182940; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018294C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CC5A0;\n    D_801CC5B0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182948);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CC5B0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182940 -> $a0 (reloaded) */\n        int qa0;   /* D_80182944[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182944 -> $a2 (reloaded) */\n        qb = (u16 *)D_80182940;\n        qa = (u16 *)D_80182944;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CC5A0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182944;\n    extern s16 * D_80182940;\n    extern u8 D_8018294C;\n    extern s16 *D_80182948;\n    extern u16 D_801CC5B0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80182944;\n\n    ax = ((u16 *)p2)[0]; pac = D_80182940; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018294C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801CC5B0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801CC5A0)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182948);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CC5B0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182940 -> $a0 (reloaded) */\n        int qa0;   /* D_80182944[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182944 -> $a2 (reloaded) */\n        qb = (u16 *)D_80182940;\n        qa = (u16 *)D_80182944;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CC5A0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:13", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.23, "objects": ["build/src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E7D8;\n    extern s16 * D_8017E7D4;\n    extern u8 D_8017E7E0;\n    extern s16 *D_8017E7DC;\n    extern u16 D_8018F070;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017E7D8 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017E7D4 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017E7E0 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017E7D8;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017E7D4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E7E0); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018F060;\n    D_8018F070 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E7DC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8018F070;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E7D4 -> $a0 (reloaded) */\n        int qa0;   /* D_8017E7D8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E7D8 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E7D4;\n        qa = (u16 *)D_8017E7D8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8018F060))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E7D8;\n    extern s16 * D_8017E7D4;\n    extern u8 D_8017E7E0;\n    extern s16 *D_8017E7DC;\n    extern u16 D_8018F070;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017E7D8;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017E7D4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E7E0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8018F070 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8018F060)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E7DC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8018F070;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E7D4 -> $a0 (reloaded) */\n        int qa0;   /* D_8017E7D8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E7D8 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E7D4;\n        qa = (u16 *)D_8017E7D8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8018F060))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:13", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.471, "objects": ["build/src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.o", "build/src/ov_SC02_003/ov_SC02_003_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018B190;\n    extern s16 * D_8018B18C;\n    extern u8 D_8018B198;\n    extern s16 *D_8018B194;\n    extern u16 D_801E6D48;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018B190 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018B18C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018B198 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018B190;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018B18C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B198); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E6D38;\n    D_801E6D48 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018B194);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E6D48;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018B18C -> $a0 (reloaded) */\n        int qa0;   /* D_8018B190[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018B190 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018B18C;\n        qa = (u16 *)D_8018B190;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E6D38))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018B190;\n    extern s16 * D_8018B18C;\n    extern u8 D_8018B198;\n    extern s16 *D_8018B194;\n    extern u16 D_801E6D48;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018B190;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018B18C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B198); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801E6D48 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801E6D38)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018B194);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E6D48;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018B18C -> $a0 (reloaded) */\n        int qa0;   /* D_8018B190[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018B190 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018B18C;\n        qa = (u16 *)D_8018B190;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E6D38))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:14", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018AA68;\n    extern s16 * D_8018AA64;\n    extern u8 D_8018AA70;\n    extern s16 *D_8018AA6C;\n    extern u16 D_801EE4B0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018AA68 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018AA64 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018AA70 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018AA68;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018AA64; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018AA70); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EE4A0;\n    D_801EE4B0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018AA6C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801EE4B0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018AA64 -> $a0 (reloaded) */\n        int qa0;   /* D_8018AA68[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018AA68 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018AA64;\n        qa = (u16 *)D_8018AA68;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801EE4A0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018AA68;\n    extern s16 * D_8018AA64;\n    extern u8 D_8018AA70;\n    extern s16 *D_8018AA6C;\n    extern u16 D_801EE4B0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018AA68;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018AA64; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018AA70); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801EE4B0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801EE4A0)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018AA6C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801EE4B0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018AA64 -> $a0 (reloaded) */\n        int qa0;   /* D_8018AA68[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018AA68 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018AA64;\n        qa = (u16 *)D_8018AA68;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801EE4A0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:14", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018005C;\n    extern s16 * D_80180058;\n    extern u8 D_80180064;\n    extern s16 *D_80180060;\n    extern u16 D_80191A20;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018005C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80180058 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80180064 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018005C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80180058; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180064); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80191A10;\n    D_80191A20 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80180060);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80191A20;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80180058 -> $a0 (reloaded) */\n        int qa0;   /* D_8018005C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018005C -> $a2 (reloaded) */\n        qb = (u16 *)D_80180058;\n        qa = (u16 *)D_8018005C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80191A10))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018005C;\n    extern s16 * D_80180058;\n    extern u8 D_80180064;\n    extern s16 *D_80180060;\n    extern u16 D_80191A20;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018005C;\n\n    ax = ((u16 *)p2)[0]; pac = D_80180058; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180064); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_80191A20 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80191A10)) {\n    found:\n        pb4 = (*(u16 * *)&D_80180060);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80191A20;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80180058 -> $a0 (reloaded) */\n        int qa0;   /* D_8018005C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018005C -> $a2 (reloaded) */\n        qb = (u16 *)D_80180058;\n        qa = (u16 *)D_8018005C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80191A10))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:14", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185204;\n    extern s16 * D_80185200;\n    extern u8 D_8018520C;\n    extern s16 *D_80185208;\n    extern u16 D_801B62E8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80185204 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80185200 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018520C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80185204;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80185200; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018520C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B62D8;\n    D_801B62E8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185208);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B62E8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185200 -> $a0 (reloaded) */\n        int qa0;   /* D_80185204[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185204 -> $a2 (reloaded) */\n        qb = (u16 *)D_80185200;\n        qa = (u16 *)D_80185204;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B62D8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185204;\n    extern s16 * D_80185200;\n    extern u8 D_8018520C;\n    extern s16 *D_80185208;\n    extern u16 D_801B62E8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80185204;\n\n    ax = ((u16 *)p2)[0]; pac = D_80185200; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018520C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B62E8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B62D8)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185208);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B62E8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185200 -> $a0 (reloaded) */\n        int qa0;   /* D_80185204[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185204 -> $a2 (reloaded) */\n        qb = (u16 *)D_80185200;\n        qa = (u16 *)D_80185204;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B62D8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:15", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.241, "objects": ["build/src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018B9D8;\n    extern s16 * D_8018B9D4;\n    extern u8 D_8018B9E0;\n    extern s16 *D_8018B9DC;\n    extern u16 D_801D1B70;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018B9D8 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018B9D4 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018B9E0 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018B9D8;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018B9D4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B9E0); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D1B60;\n    D_801D1B70 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018B9DC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D1B70;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018B9D4 -> $a0 (reloaded) */\n        int qa0;   /* D_8018B9D8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018B9D8 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018B9D4;\n        qa = (u16 *)D_8018B9D8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D1B60))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018B9D8;\n    extern s16 * D_8018B9D4;\n    extern u8 D_8018B9E0;\n    extern s16 *D_8018B9DC;\n    extern u16 D_801D1B70;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018B9D8;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018B9D4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B9E0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801D1B70 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801D1B60)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018B9DC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D1B70;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018B9D4 -> $a0 (reloaded) */\n        int qa0;   /* D_8018B9D8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018B9D8 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018B9D4;\n        qa = (u16 *)D_8018B9D8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D1B60))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:15", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184A10;\n    extern s16 * D_80184A0C;\n    extern u8 D_80184A18;\n    extern s16 *D_80184A14;\n    extern u16 D_801B2C88;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80184A10 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80184A0C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80184A18 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80184A10;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80184A0C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184A18); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B2C78;\n    D_801B2C88 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184A14);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B2C88;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184A0C -> $a0 (reloaded) */\n        int qa0;   /* D_80184A10[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184A10 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184A0C;\n        qa = (u16 *)D_80184A10;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B2C78))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184A10;\n    extern s16 * D_80184A0C;\n    extern u8 D_80184A18;\n    extern s16 *D_80184A14;\n    extern u16 D_801B2C88;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80184A10;\n\n    ax = ((u16 *)p2)[0]; pac = D_80184A0C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184A18); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B2C88 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B2C78)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184A14);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B2C88;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184A0C -> $a0 (reloaded) */\n        int qa0;   /* D_80184A10[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184A10 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184A0C;\n        qa = (u16 *)D_80184A10;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B2C78))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:15", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018B7D4;\n    extern s16 * D_8018B7D0;\n    extern u8 D_8018B7DC;\n    extern s16 *D_8018B7D8;\n    extern u16 D_801D8BD0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018B7D4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018B7D0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018B7DC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018B7D4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018B7D0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B7DC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D8BC0;\n    D_801D8BD0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018B7D8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D8BD0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018B7D0 -> $a0 (reloaded) */\n        int qa0;   /* D_8018B7D4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018B7D4 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018B7D0;\n        qa = (u16 *)D_8018B7D4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D8BC0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018B7D4;\n    extern s16 * D_8018B7D0;\n    extern u8 D_8018B7DC;\n    extern s16 *D_8018B7D8;\n    extern u16 D_801D8BD0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018B7D4;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018B7D0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B7DC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801D8BD0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801D8BC0)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018B7D8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D8BD0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018B7D0 -> $a0 (reloaded) */\n        int qa0;   /* D_8018B7D4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018B7D4 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018B7D0;\n        qa = (u16 *)D_8018B7D4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D8BC0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:16", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801866B0;\n    extern s16 * D_801866AC;\n    extern u8 D_801866B8;\n    extern s16 *D_801866B4;\n    extern u16 D_801CEE60;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801866B0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801866AC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801866B8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801866B0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801866AC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801866B8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CEE50;\n    D_801CEE60 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801866B4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CEE60;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801866AC -> $a0 (reloaded) */\n        int qa0;   /* D_801866B0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801866B0 -> $a2 (reloaded) */\n        qb = (u16 *)D_801866AC;\n        qa = (u16 *)D_801866B0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CEE50))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801866B0;\n    extern s16 * D_801866AC;\n    extern u8 D_801866B8;\n    extern s16 *D_801866B4;\n    extern u16 D_801CEE60;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801866B0;\n\n    ax = ((u16 *)p2)[0]; pac = D_801866AC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801866B8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801CEE60 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801CEE50)) {\n    found:\n        pb4 = (*(u16 * *)&D_801866B4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CEE60;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801866AC -> $a0 (reloaded) */\n        int qa0;   /* D_801866B0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801866B0 -> $a2 (reloaded) */\n        qb = (u16 *)D_801866AC;\n        qa = (u16 *)D_801866B0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CEE50))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:16", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184A64;\n    extern s16 * D_80184A60;\n    extern u8 D_80184A6C;\n    extern s16 *D_80184A68;\n    extern u16 D_801BD618;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80184A64 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80184A60 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80184A6C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80184A64;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80184A60; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184A6C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BD608;\n    D_801BD618 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184A68);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801BD618;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184A60 -> $a0 (reloaded) */\n        int qa0;   /* D_80184A64[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184A64 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184A60;\n        qa = (u16 *)D_80184A64;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801BD608))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184A64;\n    extern s16 * D_80184A60;\n    extern u8 D_80184A6C;\n    extern s16 *D_80184A68;\n    extern u16 D_801BD618;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80184A64;\n\n    ax = ((u16 *)p2)[0]; pac = D_80184A60; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184A6C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801BD618 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801BD608)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184A68);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801BD618;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184A60 -> $a0 (reloaded) */\n        int qa0;   /* D_80184A64[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184A64 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184A60;\n        qa = (u16 *)D_80184A64;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801BD608))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:16", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F690;\n    extern s16 * D_8017F68C;\n    extern u8 D_8017F698;\n    extern s16 *D_8017F694;\n    extern u16 D_8019F9C8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017F690 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017F68C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017F698 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017F690;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017F68C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F698); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019F9B8;\n    D_8019F9C8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F694);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019F9C8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F68C -> $a0 (reloaded) */\n        int qa0;   /* D_8017F690[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F690 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F68C;\n        qa = (u16 *)D_8017F690;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019F9B8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F690;\n    extern s16 * D_8017F68C;\n    extern u8 D_8017F698;\n    extern s16 *D_8017F694;\n    extern u16 D_8019F9C8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017F690;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017F68C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F698); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019F9C8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019F9B8)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F694);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019F9C8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F68C -> $a0 (reloaded) */\n        int qa0;   /* D_8017F690[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F690 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F68C;\n        qa = (u16 *)D_8017F690;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019F9B8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:17", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185A90;\n    extern s16 * D_80185A8C;\n    extern u8 D_80185A98;\n    extern s16 *D_80185A94;\n    extern u16 D_801CA440;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80185A90 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80185A8C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80185A98 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80185A90;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80185A8C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185A98); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CA430;\n    D_801CA440 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185A94);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CA440;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185A8C -> $a0 (reloaded) */\n        int qa0;   /* D_80185A90[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185A90 -> $a2 (reloaded) */\n        qb = (u16 *)D_80185A8C;\n        qa = (u16 *)D_80185A90;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CA430))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185A90;\n    extern s16 * D_80185A8C;\n    extern u8 D_80185A98;\n    extern s16 *D_80185A94;\n    extern u16 D_801CA440;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80185A90;\n\n    ax = ((u16 *)p2)[0]; pac = D_80185A8C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185A98); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801CA440 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801CA430)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185A94);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CA440;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185A8C -> $a0 (reloaded) */\n        int qa0;   /* D_80185A90[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185A90 -> $a2 (reloaded) */\n        qb = (u16 *)D_80185A8C;\n        qa = (u16 *)D_80185A90;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CA430))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:17", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185360;\n    extern s16 * D_8018535C;\n    extern u8 D_80185368;\n    extern s16 *D_80185364;\n    extern u16 D_801B7D40;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80185360 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018535C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80185368 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80185360;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018535C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185368); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B7D30;\n    D_801B7D40 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185364);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B7D40;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018535C -> $a0 (reloaded) */\n        int qa0;   /* D_80185360[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185360 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018535C;\n        qa = (u16 *)D_80185360;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B7D30))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185360;\n    extern s16 * D_8018535C;\n    extern u8 D_80185368;\n    extern s16 *D_80185364;\n    extern u16 D_801B7D40;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80185360;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018535C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185368); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B7D40 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B7D30)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185364);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B7D40;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018535C -> $a0 (reloaded) */\n        int qa0;   /* D_80185360[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185360 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018535C;\n        qa = (u16 *)D_80185360;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B7D30))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:17", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018DAA0;\n    extern s16 * D_8018DA9C;\n    extern u8 D_8018DAA8;\n    extern s16 *D_8018DAA4;\n    extern u16 D_801ED3C0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018DAA0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018DA9C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018DAA8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018DAA0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018DA9C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018DAA8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801ED3B0;\n    D_801ED3C0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018DAA4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801ED3C0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018DA9C -> $a0 (reloaded) */\n        int qa0;   /* D_8018DAA0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018DAA0 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018DA9C;\n        qa = (u16 *)D_8018DAA0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801ED3B0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018DAA0;\n    extern s16 * D_8018DA9C;\n    extern u8 D_8018DAA8;\n    extern s16 *D_8018DAA4;\n    extern u16 D_801ED3C0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018DAA0;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018DA9C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018DAA8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801ED3C0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801ED3B0)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018DAA4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801ED3C0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018DA9C -> $a0 (reloaded) */\n        int qa0;   /* D_8018DAA0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018DAA0 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018DA9C;\n        qa = (u16 *)D_8018DAA0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801ED3B0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:17", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F858;\n    extern s16 * D_8017F854;\n    extern u8 D_8017F860;\n    extern s16 *D_8017F85C;\n    extern u16 D_8018E748;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017F858 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017F854 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017F860 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017F858;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017F854; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F860); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018E738;\n    D_8018E748 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F85C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8018E748;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F854 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F858[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F858 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F854;\n        qa = (u16 *)D_8017F858;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8018E738))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F858;\n    extern s16 * D_8017F854;\n    extern u8 D_8017F860;\n    extern s16 *D_8017F85C;\n    extern u16 D_8018E748;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017F858;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017F854; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F860); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8018E748 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8018E738)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F85C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8018E748;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F854 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F858[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F858 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F854;\n        qa = (u16 *)D_8017F858;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8018E738))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:18", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018CB74;\n    extern s16 * D_8018CB70;\n    extern u8 D_8018CB7C;\n    extern s16 *D_8018CB78;\n    extern u16 D_801F60C0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018CB74 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018CB70 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018CB7C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018CB74;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018CB70; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018CB7C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801F60B0;\n    D_801F60C0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018CB78);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801F60C0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018CB70 -> $a0 (reloaded) */\n        int qa0;   /* D_8018CB74[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018CB74 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018CB70;\n        qa = (u16 *)D_8018CB74;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801F60B0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018CB74;\n    extern s16 * D_8018CB70;\n    extern u8 D_8018CB7C;\n    extern s16 *D_8018CB78;\n    extern u16 D_801F60C0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018CB74;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018CB70; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018CB7C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801F60C0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801F60B0)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018CB78);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801F60C0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018CB70 -> $a0 (reloaded) */\n        int qa0;   /* D_8018CB74[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018CB74 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018CB70;\n        qa = (u16 *)D_8018CB74;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801F60B0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:18", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018796C;\n    extern s16 * D_80187968;\n    extern u8 D_80187974;\n    extern s16 *D_80187970;\n    extern u16 D_801E8A18;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018796C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80187968 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80187974 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018796C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80187968; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80187974); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E8A08;\n    D_801E8A18 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80187970);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E8A18;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80187968 -> $a0 (reloaded) */\n        int qa0;   /* D_8018796C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018796C -> $a2 (reloaded) */\n        qb = (u16 *)D_80187968;\n        qa = (u16 *)D_8018796C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E8A08))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018796C;\n    extern s16 * D_80187968;\n    extern u8 D_80187974;\n    extern s16 *D_80187970;\n    extern u16 D_801E8A18;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018796C;\n\n    ax = ((u16 *)p2)[0]; pac = D_80187968; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80187974); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801E8A18 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801E8A08)) {\n    found:\n        pb4 = (*(u16 * *)&D_80187970);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E8A18;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80187968 -> $a0 (reloaded) */\n        int qa0;   /* D_8018796C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018796C -> $a2 (reloaded) */\n        qb = (u16 *)D_80187968;\n        qa = (u16 *)D_8018796C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E8A08))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:18", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801817FC;\n    extern s16 * D_801817F8;\n    extern u8 D_80181804;\n    extern s16 *D_80181800;\n    extern u16 D_801A0F10;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801817FC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801817F8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80181804 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801817FC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801817F8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181804); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A0F00;\n    D_801A0F10 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80181800);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A0F10;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801817F8 -> $a0 (reloaded) */\n        int qa0;   /* D_801817FC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801817FC -> $a2 (reloaded) */\n        qb = (u16 *)D_801817F8;\n        qa = (u16 *)D_801817FC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A0F00))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801817FC;\n    extern s16 * D_801817F8;\n    extern u8 D_80181804;\n    extern s16 *D_80181800;\n    extern u16 D_801A0F10;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801817FC;\n\n    ax = ((u16 *)p2)[0]; pac = D_801817F8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181804); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A0F10 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A0F00)) {\n    found:\n        pb4 = (*(u16 * *)&D_80181800);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A0F10;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801817F8 -> $a0 (reloaded) */\n        int qa0;   /* D_801817FC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801817FC -> $a2 (reloaded) */\n        qb = (u16 *)D_801817F8;\n        qa = (u16 *)D_801817FC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A0F00))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:19", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018048C;\n    extern s16 * D_80180488;\n    extern u8 D_80180494;\n    extern s16 *D_80180490;\n    extern u16 D_8019EC78;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018048C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80180488 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80180494 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018048C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80180488; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180494); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019EC68;\n    D_8019EC78 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80180490);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019EC78;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80180488 -> $a0 (reloaded) */\n        int qa0;   /* D_8018048C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018048C -> $a2 (reloaded) */\n        qb = (u16 *)D_80180488;\n        qa = (u16 *)D_8018048C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019EC68))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018048C;\n    extern s16 * D_80180488;\n    extern u8 D_80180494;\n    extern s16 *D_80180490;\n    extern u16 D_8019EC78;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018048C;\n\n    ax = ((u16 *)p2)[0]; pac = D_80180488; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180494); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019EC78 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019EC68)) {\n    found:\n        pb4 = (*(u16 * *)&D_80180490);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019EC78;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80180488 -> $a0 (reloaded) */\n        int qa0;   /* D_8018048C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018048C -> $a2 (reloaded) */\n        qb = (u16 *)D_80180488;\n        qa = (u16 *)D_8018048C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019EC68))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:19", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801814C4;\n    extern s16 * D_801814C0;\n    extern u8 D_801814CC;\n    extern s16 *D_801814C8;\n    extern u16 D_801AC000;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801814C4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801814C0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801814CC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801814C4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801814C0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801814CC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801ABFF0;\n    D_801AC000 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801814C8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801AC000;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801814C0 -> $a0 (reloaded) */\n        int qa0;   /* D_801814C4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801814C4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801814C0;\n        qa = (u16 *)D_801814C4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801ABFF0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801814C4;\n    extern s16 * D_801814C0;\n    extern u8 D_801814CC;\n    extern s16 *D_801814C8;\n    extern u16 D_801AC000;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801814C4;\n\n    ax = ((u16 *)p2)[0]; pac = D_801814C0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801814CC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801AC000 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801ABFF0)) {\n    found:\n        pb4 = (*(u16 * *)&D_801814C8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801AC000;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801814C0 -> $a0 (reloaded) */\n        int qa0;   /* D_801814C4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801814C4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801814C0;\n        qa = (u16 *)D_801814C4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801ABFF0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:19", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.245, "objects": ["build/src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E6DC;\n    extern s16 * D_8017E6D8;\n    extern u8 D_8017E6E4;\n    extern s16 *D_8017E6E0;\n    extern u16 D_80193D30;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017E6DC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017E6D8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017E6E4 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017E6DC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017E6D8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E6E4); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80193D20;\n    D_80193D30 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E6E0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80193D30;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E6D8 -> $a0 (reloaded) */\n        int qa0;   /* D_8017E6DC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E6DC -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E6D8;\n        qa = (u16 *)D_8017E6DC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80193D20))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E6DC;\n    extern s16 * D_8017E6D8;\n    extern u8 D_8017E6E4;\n    extern s16 *D_8017E6E0;\n    extern u16 D_80193D30;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017E6DC;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017E6D8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E6E4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_80193D30 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80193D20)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E6E0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80193D30;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E6D8 -> $a0 (reloaded) */\n        int qa0;   /* D_8017E6DC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E6DC -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E6D8;\n        qa = (u16 *)D_8017E6DC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80193D20))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:20", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801874A0;\n    extern s16 * D_8018749C;\n    extern u8 D_801874A8;\n    extern s16 *D_801874A4;\n    extern u16 D_801BFEF0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801874A0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018749C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801874A8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801874A0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018749C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801874A8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BFEE0;\n    D_801BFEF0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801874A4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801BFEF0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018749C -> $a0 (reloaded) */\n        int qa0;   /* D_801874A0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801874A0 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018749C;\n        qa = (u16 *)D_801874A0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801BFEE0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801874A0;\n    extern s16 * D_8018749C;\n    extern u8 D_801874A8;\n    extern s16 *D_801874A4;\n    extern u16 D_801BFEF0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801874A0;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018749C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801874A8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801BFEF0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801BFEE0)) {\n    found:\n        pb4 = (*(u16 * *)&D_801874A4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801BFEF0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018749C -> $a0 (reloaded) */\n        int qa0;   /* D_801874A0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801874A0 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018749C;\n        qa = (u16 *)D_801874A0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801BFEE0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:20", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F47C;\n    extern s16 * D_8017F478;\n    extern u8 D_8017F484;\n    extern s16 *D_8017F480;\n    extern u16 D_80197958;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017F47C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017F478 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017F484 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017F47C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017F478; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F484); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80197948;\n    D_80197958 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F480);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80197958;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F478 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F47C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F47C -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F478;\n        qa = (u16 *)D_8017F47C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80197948))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F47C;\n    extern s16 * D_8017F478;\n    extern u8 D_8017F484;\n    extern s16 *D_8017F480;\n    extern u16 D_80197958;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017F47C;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017F478; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F484); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_80197958 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80197948)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F480);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80197958;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F478 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F47C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F47C -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F478;\n        qa = (u16 *)D_8017F47C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80197948))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:20", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018BF6C;\n    extern s16 * D_8018BF68;\n    extern u8 D_8018BF74;\n    extern s16 *D_8018BF70;\n    extern u16 D_801EA228;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018BF6C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018BF68 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018BF74 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018BF6C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018BF68; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018BF74); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EA218;\n    D_801EA228 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018BF70);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801EA228;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018BF68 -> $a0 (reloaded) */\n        int qa0;   /* D_8018BF6C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018BF6C -> $a2 (reloaded) */\n        qb = (u16 *)D_8018BF68;\n        qa = (u16 *)D_8018BF6C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801EA218))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018BF6C;\n    extern s16 * D_8018BF68;\n    extern u8 D_8018BF74;\n    extern s16 *D_8018BF70;\n    extern u16 D_801EA228;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018BF6C;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018BF68; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018BF74); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801EA228 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801EA218)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018BF70);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801EA228;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018BF68 -> $a0 (reloaded) */\n        int qa0;   /* D_8018BF6C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018BF6C -> $a2 (reloaded) */\n        qb = (u16 *)D_8018BF68;\n        qa = (u16 *)D_8018BF6C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801EA218))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:21", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80187DA4;\n    extern s16 * D_80187DA0;\n    extern u8 D_80187DAC;\n    extern s16 *D_80187DA8;\n    extern u16 D_801D8200;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80187DA4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80187DA0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80187DAC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80187DA4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80187DA0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80187DAC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D81F0;\n    D_801D8200 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80187DA8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D8200;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80187DA0 -> $a0 (reloaded) */\n        int qa0;   /* D_80187DA4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80187DA4 -> $a2 (reloaded) */\n        qb = (u16 *)D_80187DA0;\n        qa = (u16 *)D_80187DA4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D81F0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80187DA4;\n    extern s16 * D_80187DA0;\n    extern u8 D_80187DAC;\n    extern s16 *D_80187DA8;\n    extern u16 D_801D8200;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80187DA4;\n\n    ax = ((u16 *)p2)[0]; pac = D_80187DA0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80187DAC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801D8200 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801D81F0)) {\n    found:\n        pb4 = (*(u16 * *)&D_80187DA8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D8200;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80187DA0 -> $a0 (reloaded) */\n        int qa0;   /* D_80187DA4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80187DA4 -> $a2 (reloaded) */\n        qb = (u16 *)D_80187DA0;\n        qa = (u16 *)D_80187DA4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D81F0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:21", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.465, "objects": ["build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o", "build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018BB00;\n    extern s16 * D_8018BAFC;\n    extern u8 D_8018BB08;\n    extern s16 *D_8018BB04;\n    extern u16 D_801E9580;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018BB00 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018BAFC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018BB08 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018BB00;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018BAFC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018BB08); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E9570;\n    D_801E9580 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018BB04);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E9580;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018BAFC -> $a0 (reloaded) */\n        int qa0;   /* D_8018BB00[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018BB00 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018BAFC;\n        qa = (u16 *)D_8018BB00;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E9570))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018BB00;\n    extern s16 * D_8018BAFC;\n    extern u8 D_8018BB08;\n    extern s16 *D_8018BB04;\n    extern u16 D_801E9580;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018BB00;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018BAFC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018BB08); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801E9580 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801E9570)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018BB04);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E9580;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018BAFC -> $a0 (reloaded) */\n        int qa0;   /* D_8018BB00[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018BB00 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018BAFC;\n        qa = (u16 *)D_8018BB00;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E9570))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:22", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80189BF8;\n    extern s16 * D_80189BF4;\n    extern u8 D_80189C00;\n    extern s16 *D_80189BFC;\n    extern u16 D_801C54B0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80189BF8 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80189BF4 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80189C00 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80189BF8;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80189BF4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80189C00); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C54A0;\n    D_801C54B0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80189BFC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C54B0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80189BF4 -> $a0 (reloaded) */\n        int qa0;   /* D_80189BF8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80189BF8 -> $a2 (reloaded) */\n        qb = (u16 *)D_80189BF4;\n        qa = (u16 *)D_80189BF8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C54A0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80189BF8;\n    extern s16 * D_80189BF4;\n    extern u8 D_80189C00;\n    extern s16 *D_80189BFC;\n    extern u16 D_801C54B0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80189BF8;\n\n    ax = ((u16 *)p2)[0]; pac = D_80189BF4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80189C00); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801C54B0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801C54A0)) {\n    found:\n        pb4 = (*(u16 * *)&D_80189BFC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C54B0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80189BF4 -> $a0 (reloaded) */\n        int qa0;   /* D_80189BF8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80189BF8 -> $a2 (reloaded) */\n        qb = (u16 *)D_80189BF4;\n        qa = (u16 *)D_80189BF8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C54A0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:22", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018CEC4;\n    extern s16 * D_8018CEC0;\n    extern u8 D_8018CECC;\n    extern s16 *D_8018CEC8;\n    extern u16 D_801D0FE8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018CEC4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018CEC0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018CECC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018CEC4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018CEC0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018CECC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D0FD8;\n    D_801D0FE8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018CEC8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D0FE8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018CEC0 -> $a0 (reloaded) */\n        int qa0;   /* D_8018CEC4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018CEC4 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018CEC0;\n        qa = (u16 *)D_8018CEC4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D0FD8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018CEC4;\n    extern s16 * D_8018CEC0;\n    extern u8 D_8018CECC;\n    extern s16 *D_8018CEC8;\n    extern u16 D_801D0FE8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018CEC4;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018CEC0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018CECC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801D0FE8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801D0FD8)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018CEC8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D0FE8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018CEC0 -> $a0 (reloaded) */\n        int qa0;   /* D_8018CEC4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018CEC4 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018CEC0;\n        qa = (u16 *)D_8018CEC4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D0FD8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:22", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801828FC;\n    extern s16 * D_801828F8;\n    extern u8 D_80182904;\n    extern s16 *D_80182900;\n    extern u16 D_801C4BF8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801828FC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801828F8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80182904 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801828FC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801828F8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182904); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C4BE8;\n    D_801C4BF8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182900);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C4BF8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801828F8 -> $a0 (reloaded) */\n        int qa0;   /* D_801828FC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801828FC -> $a2 (reloaded) */\n        qb = (u16 *)D_801828F8;\n        qa = (u16 *)D_801828FC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C4BE8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801828FC;\n    extern s16 * D_801828F8;\n    extern u8 D_80182904;\n    extern s16 *D_80182900;\n    extern u16 D_801C4BF8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801828FC;\n\n    ax = ((u16 *)p2)[0]; pac = D_801828F8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182904); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801C4BF8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801C4BE8)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182900);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C4BF8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801828F8 -> $a0 (reloaded) */\n        int qa0;   /* D_801828FC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801828FC -> $a2 (reloaded) */\n        qb = (u16 *)D_801828F8;\n        qa = (u16 *)D_801828FC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C4BE8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:22", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018C01C;\n    extern s16 * D_8018C018;\n    extern u8 D_8018C024;\n    extern s16 *D_8018C020;\n    extern u16 D_801CA918;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018C01C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018C018 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018C024 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018C01C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018C018; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018C024); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CA908;\n    D_801CA918 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018C020);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CA918;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018C018 -> $a0 (reloaded) */\n        int qa0;   /* D_8018C01C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018C01C -> $a2 (reloaded) */\n        qb = (u16 *)D_8018C018;\n        qa = (u16 *)D_8018C01C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CA908))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018C01C;\n    extern s16 * D_8018C018;\n    extern u8 D_8018C024;\n    extern s16 *D_8018C020;\n    extern u16 D_801CA918;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018C01C;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018C018; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018C024); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801CA918 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801CA908)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018C020);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CA918;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018C018 -> $a0 (reloaded) */\n        int qa0;   /* D_8018C01C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018C01C -> $a2 (reloaded) */\n        qb = (u16 *)D_8018C018;\n        qa = (u16 *)D_8018C01C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CA908))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:23", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801823E0;\n    extern s16 * D_801823DC;\n    extern u8 D_801823E8;\n    extern s16 *D_801823E4;\n    extern u16 D_801E07F8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801823E0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801823DC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801823E8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801823E0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801823DC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801823E8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E07E8;\n    D_801E07F8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801823E4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E07F8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801823DC -> $a0 (reloaded) */\n        int qa0;   /* D_801823E0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801823E0 -> $a2 (reloaded) */\n        qb = (u16 *)D_801823DC;\n        qa = (u16 *)D_801823E0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E07E8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801823E0;\n    extern s16 * D_801823DC;\n    extern u8 D_801823E8;\n    extern s16 *D_801823E4;\n    extern u16 D_801E07F8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801823E0;\n\n    ax = ((u16 *)p2)[0]; pac = D_801823DC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801823E8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801E07F8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801E07E8)) {\n    found:\n        pb4 = (*(u16 * *)&D_801823E4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E07F8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801823DC -> $a0 (reloaded) */\n        int qa0;   /* D_801823E0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801823E0 -> $a2 (reloaded) */\n        qb = (u16 *)D_801823DC;\n        qa = (u16 *)D_801823E0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E07E8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:23", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018646C;\n    extern s16 * D_80186468;\n    extern u8 D_80186474;\n    extern s16 *D_80186470;\n    extern u16 D_801CB020;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018646C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80186468 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80186474 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018646C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80186468; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186474); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CB010;\n    D_801CB020 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186470);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CB020;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186468 -> $a0 (reloaded) */\n        int qa0;   /* D_8018646C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018646C -> $a2 (reloaded) */\n        qb = (u16 *)D_80186468;\n        qa = (u16 *)D_8018646C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CB010))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018646C;\n    extern s16 * D_80186468;\n    extern u8 D_80186474;\n    extern s16 *D_80186470;\n    extern u16 D_801CB020;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018646C;\n\n    ax = ((u16 *)p2)[0]; pac = D_80186468; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186474); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801CB020 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801CB010)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186470);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CB020;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186468 -> $a0 (reloaded) */\n        int qa0;   /* D_8018646C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018646C -> $a2 (reloaded) */\n        qb = (u16 *)D_80186468;\n        qa = (u16 *)D_8018646C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CB010))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:23", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185294;\n    extern s16 * D_80185290;\n    extern u8 D_8018529C;\n    extern s16 *D_80185298;\n    extern u16 D_801B1BB0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80185294 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80185290 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018529C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80185294;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80185290; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018529C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B1BA0;\n    D_801B1BB0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185298);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B1BB0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185290 -> $a0 (reloaded) */\n        int qa0;   /* D_80185294[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185294 -> $a2 (reloaded) */\n        qb = (u16 *)D_80185290;\n        qa = (u16 *)D_80185294;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B1BA0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185294;\n    extern s16 * D_80185290;\n    extern u8 D_8018529C;\n    extern s16 *D_80185298;\n    extern u16 D_801B1BB0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80185294;\n\n    ax = ((u16 *)p2)[0]; pac = D_80185290; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018529C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B1BB0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B1BA0)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185298);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B1BB0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185290 -> $a0 (reloaded) */\n        int qa0;   /* D_80185294[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185294 -> $a2 (reloaded) */\n        qb = (u16 *)D_80185290;\n        qa = (u16 *)D_80185294;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B1BA0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:24", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801814C8;\n    extern s16 * D_801814C4;\n    extern u8 D_801814D0;\n    extern s16 *D_801814CC;\n    extern u16 D_8019AA58;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801814C8 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801814C4 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801814D0 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801814C8;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801814C4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801814D0); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019AA48;\n    D_8019AA58 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801814CC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019AA58;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801814C4 -> $a0 (reloaded) */\n        int qa0;   /* D_801814C8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801814C8 -> $a2 (reloaded) */\n        qb = (u16 *)D_801814C4;\n        qa = (u16 *)D_801814C8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019AA48))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801814C8;\n    extern s16 * D_801814C4;\n    extern u8 D_801814D0;\n    extern s16 *D_801814CC;\n    extern u16 D_8019AA58;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801814C8;\n\n    ax = ((u16 *)p2)[0]; pac = D_801814C4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801814D0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019AA58 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019AA48)) {\n    found:\n        pb4 = (*(u16 * *)&D_801814CC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019AA58;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801814C4 -> $a0 (reloaded) */\n        int qa0;   /* D_801814C8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801814C8 -> $a2 (reloaded) */\n        qb = (u16 *)D_801814C4;\n        qa = (u16 *)D_801814C8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019AA48))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:24", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80187E68;\n    extern s16 * D_80187E64;\n    extern u8 D_80187E70;\n    extern s16 *D_80187E6C;\n    extern u16 D_801D1E60;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80187E68 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80187E64 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80187E70 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80187E68;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80187E64; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80187E70); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D1E50;\n    D_801D1E60 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80187E6C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D1E60;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80187E64 -> $a0 (reloaded) */\n        int qa0;   /* D_80187E68[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80187E68 -> $a2 (reloaded) */\n        qb = (u16 *)D_80187E64;\n        qa = (u16 *)D_80187E68;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D1E50))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80187E68;\n    extern s16 * D_80187E64;\n    extern u8 D_80187E70;\n    extern s16 *D_80187E6C;\n    extern u16 D_801D1E60;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80187E68;\n\n    ax = ((u16 *)p2)[0]; pac = D_80187E64; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80187E70); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801D1E60 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801D1E50)) {\n    found:\n        pb4 = (*(u16 * *)&D_80187E6C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D1E60;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80187E64 -> $a0 (reloaded) */\n        int qa0;   /* D_80187E68[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80187E68 -> $a2 (reloaded) */\n        qb = (u16 *)D_80187E64;\n        qa = (u16 *)D_80187E68;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D1E50))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:24", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80181048;\n    extern s16 * D_80181044;\n    extern u8 D_80181050;\n    extern s16 *D_8018104C;\n    extern u16 D_80199510;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80181048 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80181044 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80181050 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80181048;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80181044; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181050); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80199500;\n    D_80199510 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018104C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80199510;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80181044 -> $a0 (reloaded) */\n        int qa0;   /* D_80181048[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80181048 -> $a2 (reloaded) */\n        qb = (u16 *)D_80181044;\n        qa = (u16 *)D_80181048;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80199500))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80181048;\n    extern s16 * D_80181044;\n    extern u8 D_80181050;\n    extern s16 *D_8018104C;\n    extern u16 D_80199510;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80181048;\n\n    ax = ((u16 *)p2)[0]; pac = D_80181044; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181050); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_80199510 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80199500)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018104C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80199510;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80181044 -> $a0 (reloaded) */\n        int qa0;   /* D_80181048[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80181048 -> $a2 (reloaded) */\n        qb = (u16 *)D_80181044;\n        qa = (u16 *)D_80181048;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80199500))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:25", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186428;\n    extern s16 * D_80186424;\n    extern u8 D_80186430;\n    extern s16 *D_8018642C;\n    extern u16 D_801A9598;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80186428 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80186424 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80186430 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80186428;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80186424; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186430); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A9588;\n    D_801A9598 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018642C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A9598;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186424 -> $a0 (reloaded) */\n        int qa0;   /* D_80186428[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186428 -> $a2 (reloaded) */\n        qb = (u16 *)D_80186424;\n        qa = (u16 *)D_80186428;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A9588))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186428;\n    extern s16 * D_80186424;\n    extern u8 D_80186430;\n    extern s16 *D_8018642C;\n    extern u16 D_801A9598;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80186428;\n\n    ax = ((u16 *)p2)[0]; pac = D_80186424; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186430); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A9598 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A9588)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018642C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A9598;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186424 -> $a0 (reloaded) */\n        int qa0;   /* D_80186428[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186428 -> $a2 (reloaded) */\n        qb = (u16 *)D_80186424;\n        qa = (u16 *)D_80186428;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A9588))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:25", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184E80;\n    extern s16 * D_80184E7C;\n    extern u8 D_80184E88;\n    extern s16 *D_80184E84;\n    extern u16 D_801C7160;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80184E80 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80184E7C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80184E88 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80184E80;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80184E7C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184E88); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C7150;\n    D_801C7160 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184E84);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C7160;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184E7C -> $a0 (reloaded) */\n        int qa0;   /* D_80184E80[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184E80 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184E7C;\n        qa = (u16 *)D_80184E80;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C7150))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184E80;\n    extern s16 * D_80184E7C;\n    extern u8 D_80184E88;\n    extern s16 *D_80184E84;\n    extern u16 D_801C7160;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80184E80;\n\n    ax = ((u16 *)p2)[0]; pac = D_80184E7C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184E88); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801C7160 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801C7150)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184E84);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C7160;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184E7C -> $a0 (reloaded) */\n        int qa0;   /* D_80184E80[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184E80 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184E7C;\n        qa = (u16 *)D_80184E80;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C7150))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:25", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801839B4;\n    extern s16 * D_801839B0;\n    extern u8 D_801839BC;\n    extern s16 *D_801839B8;\n    extern u16 D_801BDED8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801839B4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801839B0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801839BC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801839B4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801839B0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801839BC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BDEC8;\n    D_801BDED8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801839B8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801BDED8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801839B0 -> $a0 (reloaded) */\n        int qa0;   /* D_801839B4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801839B4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801839B0;\n        qa = (u16 *)D_801839B4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801BDEC8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801839B4;\n    extern s16 * D_801839B0;\n    extern u8 D_801839BC;\n    extern s16 *D_801839B8;\n    extern u16 D_801BDED8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801839B4;\n\n    ax = ((u16 *)p2)[0]; pac = D_801839B0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801839BC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801BDED8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801BDEC8)) {\n    found:\n        pb4 = (*(u16 * *)&D_801839B8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801BDED8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801839B0 -> $a0 (reloaded) */\n        int qa0;   /* D_801839B4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801839B4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801839B0;\n        qa = (u16 *)D_801839B4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801BDEC8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:26", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801858B4;\n    extern s16 * D_801858B0;\n    extern u8 D_801858BC;\n    extern s16 *D_801858B8;\n    extern u16 D_801C4208;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801858B4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801858B0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801858BC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801858B4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801858B0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801858BC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C41F8;\n    D_801C4208 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801858B8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C4208;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801858B0 -> $a0 (reloaded) */\n        int qa0;   /* D_801858B4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801858B4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801858B0;\n        qa = (u16 *)D_801858B4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C41F8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801858B4;\n    extern s16 * D_801858B0;\n    extern u8 D_801858BC;\n    extern s16 *D_801858B8;\n    extern u16 D_801C4208;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801858B4;\n\n    ax = ((u16 *)p2)[0]; pac = D_801858B0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801858BC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801C4208 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801C41F8)) {\n    found:\n        pb4 = (*(u16 * *)&D_801858B8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C4208;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801858B0 -> $a0 (reloaded) */\n        int qa0;   /* D_801858B4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801858B4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801858B0;\n        qa = (u16 *)D_801858B4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C41F8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:26", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801846C4;\n    extern s16 * D_801846C0;\n    extern u8 D_801846CC;\n    extern s16 *D_801846C8;\n    extern u16 D_801C3858;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801846C4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801846C0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801846CC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801846C4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801846C0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801846CC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C3848;\n    D_801C3858 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801846C8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C3858;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801846C0 -> $a0 (reloaded) */\n        int qa0;   /* D_801846C4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801846C4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801846C0;\n        qa = (u16 *)D_801846C4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C3848))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801846C4;\n    extern s16 * D_801846C0;\n    extern u8 D_801846CC;\n    extern s16 *D_801846C8;\n    extern u16 D_801C3858;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801846C4;\n\n    ax = ((u16 *)p2)[0]; pac = D_801846C0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801846CC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801C3858 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801C3848)) {\n    found:\n        pb4 = (*(u16 * *)&D_801846C8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C3858;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801846C0 -> $a0 (reloaded) */\n        int qa0;   /* D_801846C4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801846C4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801846C0;\n        qa = (u16 *)D_801846C4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C3848))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:26", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80183E5C;\n    extern s16 * D_80183E58;\n    extern u8 D_80183E64;\n    extern s16 *D_80183E60;\n    extern u16 D_8019CA28;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80183E5C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80183E58 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80183E64 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80183E5C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80183E58; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183E64); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019CA18;\n    D_8019CA28 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80183E60);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019CA28;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80183E58 -> $a0 (reloaded) */\n        int qa0;   /* D_80183E5C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80183E5C -> $a2 (reloaded) */\n        qb = (u16 *)D_80183E58;\n        qa = (u16 *)D_80183E5C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019CA18))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80183E5C;\n    extern s16 * D_80183E58;\n    extern u8 D_80183E64;\n    extern s16 *D_80183E60;\n    extern u16 D_8019CA28;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80183E5C;\n\n    ax = ((u16 *)p2)[0]; pac = D_80183E58; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183E64); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019CA28 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019CA18)) {\n    found:\n        pb4 = (*(u16 * *)&D_80183E60);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019CA28;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80183E58 -> $a0 (reloaded) */\n        int qa0;   /* D_80183E5C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80183E5C -> $a2 (reloaded) */\n        qb = (u16 *)D_80183E58;\n        qa = (u16 *)D_80183E5C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019CA18))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:27", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186714;\n    extern s16 * D_80186710;\n    extern u8 D_8018671C;\n    extern s16 *D_80186718;\n    extern u16 D_801B86A0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80186714 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80186710 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018671C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80186714;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80186710; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018671C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8690;\n    D_801B86A0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186718);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B86A0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186710 -> $a0 (reloaded) */\n        int qa0;   /* D_80186714[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186714 -> $a2 (reloaded) */\n        qb = (u16 *)D_80186710;\n        qa = (u16 *)D_80186714;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B8690))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186714;\n    extern s16 * D_80186710;\n    extern u8 D_8018671C;\n    extern s16 *D_80186718;\n    extern u16 D_801B86A0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80186714;\n\n    ax = ((u16 *)p2)[0]; pac = D_80186710; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018671C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B86A0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B8690)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186718);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B86A0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186710 -> $a0 (reloaded) */\n        int qa0;   /* D_80186714[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186714 -> $a2 (reloaded) */\n        qb = (u16 *)D_80186710;\n        qa = (u16 *)D_80186714;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B8690))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:27", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018A8DC;\n    extern s16 * D_8018A8D8;\n    extern u8 D_8018A8E4;\n    extern s16 *D_8018A8E0;\n    extern u16 D_801B8380;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018A8DC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018A8D8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018A8E4 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018A8DC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018A8D8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018A8E4); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8370;\n    D_801B8380 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018A8E0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B8380;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018A8D8 -> $a0 (reloaded) */\n        int qa0;   /* D_8018A8DC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018A8DC -> $a2 (reloaded) */\n        qb = (u16 *)D_8018A8D8;\n        qa = (u16 *)D_8018A8DC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B8370))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018A8DC;\n    extern s16 * D_8018A8D8;\n    extern u8 D_8018A8E4;\n    extern s16 *D_8018A8E0;\n    extern u16 D_801B8380;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018A8DC;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018A8D8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018A8E4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B8380 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B8370)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018A8E0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B8380;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018A8D8 -> $a0 (reloaded) */\n        int qa0;   /* D_8018A8DC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018A8DC -> $a2 (reloaded) */\n        qb = (u16 *)D_8018A8D8;\n        qa = (u16 *)D_8018A8DC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B8370))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:27", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018B254;\n    extern s16 * D_8018B250;\n    extern u8 D_8018B25C;\n    extern s16 *D_8018B258;\n    extern u16 D_801BEDF0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018B254 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018B250 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018B25C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018B254;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018B250; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B25C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BEDE0;\n    D_801BEDF0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018B258);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801BEDF0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018B250 -> $a0 (reloaded) */\n        int qa0;   /* D_8018B254[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018B254 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018B250;\n        qa = (u16 *)D_8018B254;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801BEDE0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018B254;\n    extern s16 * D_8018B250;\n    extern u8 D_8018B25C;\n    extern s16 *D_8018B258;\n    extern u16 D_801BEDF0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018B254;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018B250; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B25C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801BEDF0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801BEDE0)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018B258);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801BEDF0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018B250 -> $a0 (reloaded) */\n        int qa0;   /* D_8018B254[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018B254 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018B250;\n        qa = (u16 *)D_8018B254;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801BEDE0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:28", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E8E0;\n    extern s16 * D_8017E8DC;\n    extern u8 D_8017E8E8;\n    extern s16 *D_8017E8E4;\n    extern u16 D_80199080;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017E8E0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017E8DC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017E8E8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017E8E0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017E8DC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E8E8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80199070;\n    D_80199080 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E8E4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80199080;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E8DC -> $a0 (reloaded) */\n        int qa0;   /* D_8017E8E0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E8E0 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E8DC;\n        qa = (u16 *)D_8017E8E0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80199070))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E8E0;\n    extern s16 * D_8017E8DC;\n    extern u8 D_8017E8E8;\n    extern s16 *D_8017E8E4;\n    extern u16 D_80199080;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017E8E0;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017E8DC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E8E8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_80199080 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80199070)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E8E4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80199080;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E8DC -> $a0 (reloaded) */\n        int qa0;   /* D_8017E8E0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E8E0 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E8DC;\n        qa = (u16 *)D_8017E8E0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80199070))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:28", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80181234;\n    extern s16 * D_80181230;\n    extern u8 D_8018123C;\n    extern s16 *D_80181238;\n    extern u16 D_801A0670;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80181234 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80181230 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018123C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80181234;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80181230; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018123C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A0660;\n    D_801A0670 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80181238);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A0670;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80181230 -> $a0 (reloaded) */\n        int qa0;   /* D_80181234[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80181234 -> $a2 (reloaded) */\n        qb = (u16 *)D_80181230;\n        qa = (u16 *)D_80181234;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A0660))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80181234;\n    extern s16 * D_80181230;\n    extern u8 D_8018123C;\n    extern s16 *D_80181238;\n    extern u16 D_801A0670;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80181234;\n\n    ax = ((u16 *)p2)[0]; pac = D_80181230; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018123C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A0670 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A0660)) {\n    found:\n        pb4 = (*(u16 * *)&D_80181238);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A0670;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80181230 -> $a0 (reloaded) */\n        int qa0;   /* D_80181234[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80181234 -> $a2 (reloaded) */\n        qb = (u16 *)D_80181230;\n        qa = (u16 *)D_80181234;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A0660))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:28", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182300;\n    extern s16 * D_801822FC;\n    extern u8 D_80182308;\n    extern s16 *D_80182304;\n    extern u16 D_801A0E28;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80182300 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801822FC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80182308 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80182300;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801822FC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182308); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A0E18;\n    D_801A0E28 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182304);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A0E28;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801822FC -> $a0 (reloaded) */\n        int qa0;   /* D_80182300[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182300 -> $a2 (reloaded) */\n        qb = (u16 *)D_801822FC;\n        qa = (u16 *)D_80182300;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A0E18))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182300;\n    extern s16 * D_801822FC;\n    extern u8 D_80182308;\n    extern s16 *D_80182304;\n    extern u16 D_801A0E28;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80182300;\n\n    ax = ((u16 *)p2)[0]; pac = D_801822FC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182308); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A0E28 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A0E18)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182304);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A0E28;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801822FC -> $a0 (reloaded) */\n        int qa0;   /* D_80182300[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182300 -> $a2 (reloaded) */\n        qb = (u16 *)D_801822FC;\n        qa = (u16 *)D_80182300;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A0E18))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:29", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184EB4;\n    extern s16 * D_80184EB0;\n    extern u8 D_80184EBC;\n    extern s16 *D_80184EB8;\n    extern u16 D_801B8330;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80184EB4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80184EB0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80184EBC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80184EB4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80184EB0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184EBC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8320;\n    D_801B8330 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184EB8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B8330;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184EB0 -> $a0 (reloaded) */\n        int qa0;   /* D_80184EB4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184EB4 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184EB0;\n        qa = (u16 *)D_80184EB4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B8320))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184EB4;\n    extern s16 * D_80184EB0;\n    extern u8 D_80184EBC;\n    extern s16 *D_80184EB8;\n    extern u16 D_801B8330;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80184EB4;\n\n    ax = ((u16 *)p2)[0]; pac = D_80184EB0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184EBC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B8330 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B8320)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184EB8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B8330;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184EB0 -> $a0 (reloaded) */\n        int qa0;   /* D_80184EB4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184EB4 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184EB0;\n        qa = (u16 *)D_80184EB4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B8320))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:29", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185CBC;\n    extern s16 * D_80185CB8;\n    extern u8 D_80185CC4;\n    extern s16 *D_80185CC0;\n    extern u16 D_801ABB90;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80185CBC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80185CB8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80185CC4 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80185CBC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80185CB8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185CC4); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801ABB80;\n    D_801ABB90 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185CC0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801ABB90;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185CB8 -> $a0 (reloaded) */\n        int qa0;   /* D_80185CBC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185CBC -> $a2 (reloaded) */\n        qb = (u16 *)D_80185CB8;\n        qa = (u16 *)D_80185CBC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801ABB80))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185CBC;\n    extern s16 * D_80185CB8;\n    extern u8 D_80185CC4;\n    extern s16 *D_80185CC0;\n    extern u16 D_801ABB90;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80185CBC;\n\n    ax = ((u16 *)p2)[0]; pac = D_80185CB8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185CC4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801ABB90 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801ABB80)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185CC0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801ABB90;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185CB8 -> $a0 (reloaded) */\n        int qa0;   /* D_80185CBC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185CBC -> $a2 (reloaded) */\n        qb = (u16 *)D_80185CB8;\n        qa = (u16 *)D_80185CBC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801ABB80))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:29", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184E50;\n    extern s16 * D_80184E4C;\n    extern u8 D_80184E58;\n    extern s16 *D_80184E54;\n    extern u16 D_801CD018;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80184E50 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80184E4C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80184E58 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80184E50;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80184E4C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184E58); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CD008;\n    D_801CD018 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184E54);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CD018;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184E4C -> $a0 (reloaded) */\n        int qa0;   /* D_80184E50[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184E50 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184E4C;\n        qa = (u16 *)D_80184E50;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CD008))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184E50;\n    extern s16 * D_80184E4C;\n    extern u8 D_80184E58;\n    extern s16 *D_80184E54;\n    extern u16 D_801CD018;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80184E50;\n\n    ax = ((u16 *)p2)[0]; pac = D_80184E4C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184E58); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801CD018 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801CD008)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184E54);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CD018;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184E4C -> $a0 (reloaded) */\n        int qa0;   /* D_80184E50[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184E50 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184E4C;\n        qa = (u16 *)D_80184E50;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CD008))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:29", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017EFD4;\n    extern s16 * D_8017EFD0;\n    extern u8 D_8017EFDC;\n    extern s16 *D_8017EFD8;\n    extern u16 D_801A83B8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017EFD4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017EFD0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017EFDC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017EFD4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017EFD0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017EFDC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A83A8;\n    D_801A83B8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017EFD8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A83B8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017EFD0 -> $a0 (reloaded) */\n        int qa0;   /* D_8017EFD4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017EFD4 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017EFD0;\n        qa = (u16 *)D_8017EFD4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A83A8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017EFD4;\n    extern s16 * D_8017EFD0;\n    extern u8 D_8017EFDC;\n    extern s16 *D_8017EFD8;\n    extern u16 D_801A83B8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017EFD4;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017EFD0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017EFDC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A83B8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A83A8)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017EFD8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A83B8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017EFD0 -> $a0 (reloaded) */\n        int qa0;   /* D_8017EFD4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017EFD4 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017EFD0;\n        qa = (u16 *)D_8017EFD4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A83A8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:30", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80180A40;\n    extern s16 * D_80180A3C;\n    extern u8 D_80180A48;\n    extern s16 *D_80180A44;\n    extern u16 D_80193D10;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80180A40 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80180A3C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80180A48 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80180A40;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80180A3C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180A48); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80193D00;\n    D_80193D10 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80180A44);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80193D10;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80180A3C -> $a0 (reloaded) */\n        int qa0;   /* D_80180A40[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80180A40 -> $a2 (reloaded) */\n        qb = (u16 *)D_80180A3C;\n        qa = (u16 *)D_80180A40;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80193D00))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80180A40;\n    extern s16 * D_80180A3C;\n    extern u8 D_80180A48;\n    extern s16 *D_80180A44;\n    extern u16 D_80193D10;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80180A40;\n\n    ax = ((u16 *)p2)[0]; pac = D_80180A3C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180A48); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_80193D10 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80193D00)) {\n    found:\n        pb4 = (*(u16 * *)&D_80180A44);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80193D10;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80180A3C -> $a0 (reloaded) */\n        int qa0;   /* D_80180A40[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80180A40 -> $a2 (reloaded) */\n        qb = (u16 *)D_80180A3C;\n        qa = (u16 *)D_80180A40;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80193D00))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:30", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018336C;\n    extern s16 * D_80183368;\n    extern u8 D_80183374;\n    extern s16 *D_80183370;\n    extern u16 D_801A4720;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018336C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80183368 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80183374 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018336C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80183368; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183374); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A4710;\n    D_801A4720 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80183370);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A4720;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80183368 -> $a0 (reloaded) */\n        int qa0;   /* D_8018336C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018336C -> $a2 (reloaded) */\n        qb = (u16 *)D_80183368;\n        qa = (u16 *)D_8018336C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A4710))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018336C;\n    extern s16 * D_80183368;\n    extern u8 D_80183374;\n    extern s16 *D_80183370;\n    extern u16 D_801A4720;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018336C;\n\n    ax = ((u16 *)p2)[0]; pac = D_80183368; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183374); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A4720 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A4710)) {\n    found:\n        pb4 = (*(u16 * *)&D_80183370);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A4720;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80183368 -> $a0 (reloaded) */\n        int qa0;   /* D_8018336C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018336C -> $a2 (reloaded) */\n        qb = (u16 *)D_80183368;\n        qa = (u16 *)D_8018336C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A4710))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:30", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182E44;\n    extern s16 * D_80182E40;\n    extern u8 D_80182E4C;\n    extern s16 *D_80182E48;\n    extern u16 D_801968A0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80182E44 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80182E40 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80182E4C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80182E44;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80182E40; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182E4C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80196890;\n    D_801968A0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182E48);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801968A0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182E40 -> $a0 (reloaded) */\n        int qa0;   /* D_80182E44[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182E44 -> $a2 (reloaded) */\n        qb = (u16 *)D_80182E40;\n        qa = (u16 *)D_80182E44;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80196890))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182E44;\n    extern s16 * D_80182E40;\n    extern u8 D_80182E4C;\n    extern s16 *D_80182E48;\n    extern u16 D_801968A0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80182E44;\n\n    ax = ((u16 *)p2)[0]; pac = D_80182E40; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182E4C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801968A0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80196890)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182E48);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801968A0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182E40 -> $a0 (reloaded) */\n        int qa0;   /* D_80182E44[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182E44 -> $a2 (reloaded) */\n        qb = (u16 *)D_80182E40;\n        qa = (u16 *)D_80182E44;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80196890))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:31", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182718;\n    extern s16 * D_80182714;\n    extern u8 D_80182720;\n    extern s16 *D_8018271C;\n    extern u16 D_801ADA10;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80182718 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80182714 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80182720 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80182718;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80182714; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182720); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801ADA00;\n    D_801ADA10 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018271C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801ADA10;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182714 -> $a0 (reloaded) */\n        int qa0;   /* D_80182718[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182718 -> $a2 (reloaded) */\n        qb = (u16 *)D_80182714;\n        qa = (u16 *)D_80182718;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801ADA00))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182718;\n    extern s16 * D_80182714;\n    extern u8 D_80182720;\n    extern s16 *D_8018271C;\n    extern u16 D_801ADA10;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80182718;\n\n    ax = ((u16 *)p2)[0]; pac = D_80182714; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182720); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801ADA10 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801ADA00)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018271C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801ADA10;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182714 -> $a0 (reloaded) */\n        int qa0;   /* D_80182718[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182718 -> $a2 (reloaded) */\n        qb = (u16 *)D_80182714;\n        qa = (u16 *)D_80182718;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801ADA00))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:31", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018B144;\n    extern s16 * D_8018B140;\n    extern u8 D_8018B14C;\n    extern s16 *D_8018B148;\n    extern u16 D_801E0538;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018B144 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018B140 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018B14C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018B144;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018B140; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B14C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E0528;\n    D_801E0538 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018B148);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E0538;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018B140 -> $a0 (reloaded) */\n        int qa0;   /* D_8018B144[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018B144 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018B140;\n        qa = (u16 *)D_8018B144;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E0528))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018B144;\n    extern s16 * D_8018B140;\n    extern u8 D_8018B14C;\n    extern s16 *D_8018B148;\n    extern u16 D_801E0538;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018B144;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018B140; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B14C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801E0538 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801E0528)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018B148);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E0538;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018B140 -> $a0 (reloaded) */\n        int qa0;   /* D_8018B144[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018B144 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018B140;\n        qa = (u16 *)D_8018B144;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E0528))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:31", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80183818;\n    extern s16 * D_80183814;\n    extern u8 D_80183820;\n    extern s16 *D_8018381C;\n    extern u16 D_801A87A8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80183818 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80183814 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80183820 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80183818;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80183814; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183820); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A8798;\n    D_801A87A8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018381C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A87A8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80183814 -> $a0 (reloaded) */\n        int qa0;   /* D_80183818[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80183818 -> $a2 (reloaded) */\n        qb = (u16 *)D_80183814;\n        qa = (u16 *)D_80183818;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A8798))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80183818;\n    extern s16 * D_80183814;\n    extern u8 D_80183820;\n    extern s16 *D_8018381C;\n    extern u16 D_801A87A8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80183818;\n\n    ax = ((u16 *)p2)[0]; pac = D_80183814; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183820); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A87A8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A8798)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018381C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A87A8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80183814 -> $a0 (reloaded) */\n        int qa0;   /* D_80183818[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80183818 -> $a2 (reloaded) */\n        qb = (u16 *)D_80183814;\n        qa = (u16 *)D_80183818;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A8798))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:32", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184314;\n    extern s16 * D_80184310;\n    extern u8 D_8018431C;\n    extern s16 *D_80184318;\n    extern u16 D_801C2E30;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80184314 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80184310 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018431C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80184314;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80184310; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018431C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C2E20;\n    D_801C2E30 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184318);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C2E30;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184310 -> $a0 (reloaded) */\n        int qa0;   /* D_80184314[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184314 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184310;\n        qa = (u16 *)D_80184314;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C2E20))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184314;\n    extern s16 * D_80184310;\n    extern u8 D_8018431C;\n    extern s16 *D_80184318;\n    extern u16 D_801C2E30;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80184314;\n\n    ax = ((u16 *)p2)[0]; pac = D_80184310; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018431C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801C2E30 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801C2E20)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184318);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C2E30;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184310 -> $a0 (reloaded) */\n        int qa0;   /* D_80184314[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184314 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184310;\n        qa = (u16 *)D_80184314;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C2E20))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:32", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.47, "objects": ["build/src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.o", "build/src/ov_SC03_119/ov_SC03_119_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80189EFC;\n    extern s16 * D_80189EF8;\n    extern u8 D_80189F04;\n    extern s16 *D_80189F00;\n    extern u16 D_801D2F68;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80189EFC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80189EF8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80189F04 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80189EFC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80189EF8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80189F04); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D2F58;\n    D_801D2F68 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80189F00);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D2F68;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80189EF8 -> $a0 (reloaded) */\n        int qa0;   /* D_80189EFC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80189EFC -> $a2 (reloaded) */\n        qb = (u16 *)D_80189EF8;\n        qa = (u16 *)D_80189EFC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D2F58))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80189EFC;\n    extern s16 * D_80189EF8;\n    extern u8 D_80189F04;\n    extern s16 *D_80189F00;\n    extern u16 D_801D2F68;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80189EFC;\n\n    ax = ((u16 *)p2)[0]; pac = D_80189EF8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80189F04); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801D2F68 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801D2F58)) {\n    found:\n        pb4 = (*(u16 * *)&D_80189F00);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D2F68;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80189EF8 -> $a0 (reloaded) */\n        int qa0;   /* D_80189EFC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80189EFC -> $a2 (reloaded) */\n        qb = (u16 *)D_80189EF8;\n        qa = (u16 *)D_80189EFC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D2F58))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:33", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80188984;\n    extern s16 * D_80188980;\n    extern u8 D_8018898C;\n    extern s16 *D_80188988;\n    extern u16 D_801BFAB8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80188984 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80188980 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018898C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80188984;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80188980; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018898C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BFAA8;\n    D_801BFAB8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80188988);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801BFAB8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80188980 -> $a0 (reloaded) */\n        int qa0;   /* D_80188984[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80188984 -> $a2 (reloaded) */\n        qb = (u16 *)D_80188980;\n        qa = (u16 *)D_80188984;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801BFAA8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80188984;\n    extern s16 * D_80188980;\n    extern u8 D_8018898C;\n    extern s16 *D_80188988;\n    extern u16 D_801BFAB8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80188984;\n\n    ax = ((u16 *)p2)[0]; pac = D_80188980; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018898C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801BFAB8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801BFAA8)) {\n    found:\n        pb4 = (*(u16 * *)&D_80188988);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801BFAB8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80188980 -> $a0 (reloaded) */\n        int qa0;   /* D_80188984[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80188984 -> $a2 (reloaded) */\n        qb = (u16 *)D_80188980;\n        qa = (u16 *)D_80188984;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801BFAA8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:33", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.231, "objects": ["build/src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80180168;\n    extern s16 * D_80180164;\n    extern u8 D_80180170;\n    extern s16 *D_8018016C;\n    extern u16 D_8019C9A0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80180168 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80180164 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80180170 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80180168;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80180164; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180170); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019C990;\n    D_8019C9A0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018016C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019C9A0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80180164 -> $a0 (reloaded) */\n        int qa0;   /* D_80180168[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80180168 -> $a2 (reloaded) */\n        qb = (u16 *)D_80180164;\n        qa = (u16 *)D_80180168;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019C990))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80180168;\n    extern s16 * D_80180164;\n    extern u8 D_80180170;\n    extern s16 *D_8018016C;\n    extern u16 D_8019C9A0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80180168;\n\n    ax = ((u16 *)p2)[0]; pac = D_80180164; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180170); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019C9A0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019C990)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018016C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019C9A0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80180164 -> $a0 (reloaded) */\n        int qa0;   /* D_80180168[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80180168 -> $a2 (reloaded) */\n        qb = (u16 *)D_80180164;\n        qa = (u16 *)D_80180168;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019C990))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:33", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184C54;\n    extern s16 * D_80184C50;\n    extern u8 D_80184C5C;\n    extern s16 *D_80184C58;\n    extern u16 D_801B2520;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80184C54 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80184C50 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80184C5C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80184C54;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80184C50; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184C5C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B2510;\n    D_801B2520 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184C58);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B2520;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184C50 -> $a0 (reloaded) */\n        int qa0;   /* D_80184C54[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184C54 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184C50;\n        qa = (u16 *)D_80184C54;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B2510))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184C54;\n    extern s16 * D_80184C50;\n    extern u8 D_80184C5C;\n    extern s16 *D_80184C58;\n    extern u16 D_801B2520;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80184C54;\n\n    ax = ((u16 *)p2)[0]; pac = D_80184C50; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184C5C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B2520 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B2510)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184C58);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B2520;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184C50 -> $a0 (reloaded) */\n        int qa0;   /* D_80184C54[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184C54 -> $a2 (reloaded) */\n        qb = (u16 *)D_80184C50;\n        qa = (u16 *)D_80184C54;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B2510))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:34", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F084;\n    extern s16 * D_8017F080;\n    extern u8 D_8017F08C;\n    extern s16 *D_8017F088;\n    extern u16 D_80196E40;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017F084 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017F080 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017F08C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017F084;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017F080; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F08C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80196E30;\n    D_80196E40 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F088);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80196E40;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F080 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F084[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F084 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F080;\n        qa = (u16 *)D_8017F084;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80196E30))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F084;\n    extern s16 * D_8017F080;\n    extern u8 D_8017F08C;\n    extern s16 *D_8017F088;\n    extern u16 D_80196E40;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017F084;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017F080; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F08C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_80196E40 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80196E30)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F088);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80196E40;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F080 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F084[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F084 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F080;\n        qa = (u16 *)D_8017F084;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80196E30))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:34", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182720;\n    extern s16 * D_8018271C;\n    extern u8 D_80182728;\n    extern s16 *D_80182724;\n    extern u16 D_8019A720;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80182720 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018271C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80182728 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80182720;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018271C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182728); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019A710;\n    D_8019A720 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182724);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019A720;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018271C -> $a0 (reloaded) */\n        int qa0;   /* D_80182720[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182720 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018271C;\n        qa = (u16 *)D_80182720;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019A710))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182720;\n    extern s16 * D_8018271C;\n    extern u8 D_80182728;\n    extern s16 *D_80182724;\n    extern u16 D_8019A720;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80182720;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018271C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182728); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019A720 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019A710)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182724);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019A720;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018271C -> $a0 (reloaded) */\n        int qa0;   /* D_80182720[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182720 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018271C;\n        qa = (u16 *)D_80182720;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019A710))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:34", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E730;\n    extern s16 * D_8017E72C;\n    extern u8 D_8017E738;\n    extern s16 *D_8017E734;\n    extern u16 D_8018E2D8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017E730 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017E72C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017E738 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017E730;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017E72C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E738); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018E2C8;\n    D_8018E2D8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E734);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8018E2D8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E72C -> $a0 (reloaded) */\n        int qa0;   /* D_8017E730[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E730 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E72C;\n        qa = (u16 *)D_8017E730;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8018E2C8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E730;\n    extern s16 * D_8017E72C;\n    extern u8 D_8017E738;\n    extern s16 *D_8017E734;\n    extern u16 D_8018E2D8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017E730;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017E72C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E738); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8018E2D8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8018E2C8)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E734);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8018E2D8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E72C -> $a0 (reloaded) */\n        int qa0;   /* D_8017E730[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E730 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E72C;\n        qa = (u16 *)D_8017E730;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8018E2C8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:34", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186120;\n    extern s16 * D_8018611C;\n    extern u8 D_80186128;\n    extern s16 *D_80186124;\n    extern u16 D_801B3F58;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80186120 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018611C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80186128 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80186120;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018611C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186128); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B3F48;\n    D_801B3F58 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186124);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B3F58;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018611C -> $a0 (reloaded) */\n        int qa0;   /* D_80186120[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186120 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018611C;\n        qa = (u16 *)D_80186120;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B3F48))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186120;\n    extern s16 * D_8018611C;\n    extern u8 D_80186128;\n    extern s16 *D_80186124;\n    extern u16 D_801B3F58;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80186120;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018611C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186128); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B3F58 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B3F48)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186124);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B3F58;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018611C -> $a0 (reloaded) */\n        int qa0;   /* D_80186120[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186120 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018611C;\n        qa = (u16 *)D_80186120;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B3F48))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:35", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80188088;\n    extern s16 * D_80188084;\n    extern u8 D_80188090;\n    extern s16 *D_8018808C;\n    extern u16 D_801C06F8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80188088 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80188084 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80188090 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80188088;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80188084; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80188090); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C06E8;\n    D_801C06F8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018808C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C06F8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80188084 -> $a0 (reloaded) */\n        int qa0;   /* D_80188088[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80188088 -> $a2 (reloaded) */\n        qb = (u16 *)D_80188084;\n        qa = (u16 *)D_80188088;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C06E8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80188088;\n    extern s16 * D_80188084;\n    extern u8 D_80188090;\n    extern s16 *D_8018808C;\n    extern u16 D_801C06F8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80188088;\n\n    ax = ((u16 *)p2)[0]; pac = D_80188084; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80188090); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801C06F8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801C06E8)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018808C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C06F8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80188084 -> $a0 (reloaded) */\n        int qa0;   /* D_80188088[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80188088 -> $a2 (reloaded) */\n        qb = (u16 *)D_80188084;\n        qa = (u16 *)D_80188088;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C06E8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:35", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017EB94;\n    extern s16 * D_8017EB90;\n    extern u8 D_8017EB9C;\n    extern s16 *D_8017EB98;\n    extern u16 D_801909B0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017EB94 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017EB90 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017EB9C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017EB94;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017EB90; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017EB9C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801909A0;\n    D_801909B0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017EB98);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801909B0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017EB90 -> $a0 (reloaded) */\n        int qa0;   /* D_8017EB94[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017EB94 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017EB90;\n        qa = (u16 *)D_8017EB94;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801909A0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017EB94;\n    extern s16 * D_8017EB90;\n    extern u8 D_8017EB9C;\n    extern s16 *D_8017EB98;\n    extern u16 D_801909B0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017EB94;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017EB90; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017EB9C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801909B0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801909A0)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017EB98);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801909B0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017EB90 -> $a0 (reloaded) */\n        int qa0;   /* D_8017EB94[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017EB94 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017EB90;\n        qa = (u16 *)D_8017EB94;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801909A0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:35", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80180590;\n    extern s16 * D_8018058C;\n    extern u8 D_80180598;\n    extern s16 *D_80180594;\n    extern u16 D_801A5840;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80180590 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018058C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80180598 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80180590;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018058C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180598); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A5830;\n    D_801A5840 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80180594);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A5840;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018058C -> $a0 (reloaded) */\n        int qa0;   /* D_80180590[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80180590 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018058C;\n        qa = (u16 *)D_80180590;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A5830))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80180590;\n    extern s16 * D_8018058C;\n    extern u8 D_80180598;\n    extern s16 *D_80180594;\n    extern u16 D_801A5840;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80180590;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018058C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180598); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A5840 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A5830)) {\n    found:\n        pb4 = (*(u16 * *)&D_80180594);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A5840;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018058C -> $a0 (reloaded) */\n        int qa0;   /* D_80180590[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80180590 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018058C;\n        qa = (u16 *)D_80180590;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A5830))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:36", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184ACC;\n    extern s16 * D_80184AC8;\n    extern u8 D_80184AD4;\n    extern s16 *D_80184AD0;\n    extern u16 D_801C7698;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80184ACC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80184AC8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80184AD4 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80184ACC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80184AC8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184AD4); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C7688;\n    D_801C7698 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184AD0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C7698;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184AC8 -> $a0 (reloaded) */\n        int qa0;   /* D_80184ACC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184ACC -> $a2 (reloaded) */\n        qb = (u16 *)D_80184AC8;\n        qa = (u16 *)D_80184ACC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C7688))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80184ACC;\n    extern s16 * D_80184AC8;\n    extern u8 D_80184AD4;\n    extern s16 *D_80184AD0;\n    extern u16 D_801C7698;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80184ACC;\n\n    ax = ((u16 *)p2)[0]; pac = D_80184AC8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184AD4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801C7698 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801C7688)) {\n    found:\n        pb4 = (*(u16 * *)&D_80184AD0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C7698;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80184AC8 -> $a0 (reloaded) */\n        int qa0;   /* D_80184ACC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80184ACC -> $a2 (reloaded) */\n        qb = (u16 *)D_80184AC8;\n        qa = (u16 *)D_80184ACC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C7688))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:36", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E820;\n    extern s16 * D_8017E81C;\n    extern u8 D_8017E828;\n    extern s16 *D_8017E824;\n    extern u16 D_80199828;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017E820 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017E81C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017E828 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017E820;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017E81C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E828); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80199818;\n    D_80199828 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E824);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80199828;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E81C -> $a0 (reloaded) */\n        int qa0;   /* D_8017E820[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E820 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E81C;\n        qa = (u16 *)D_8017E820;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80199818))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E820;\n    extern s16 * D_8017E81C;\n    extern u8 D_8017E828;\n    extern s16 *D_8017E824;\n    extern u16 D_80199828;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017E820;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017E81C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E828); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_80199828 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80199818)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E824);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80199828;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E81C -> $a0 (reloaded) */\n        int qa0;   /* D_8017E820[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E820 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E81C;\n        qa = (u16 *)D_8017E820;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80199818))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:36", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801838E0;\n    extern s16 * D_801838DC;\n    extern u8 D_801838E8;\n    extern s16 *D_801838E4;\n    extern u16 D_801BB0A0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801838E0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801838DC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801838E8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801838E0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801838DC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801838E8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801BB090;\n    D_801BB0A0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801838E4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801BB0A0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801838DC -> $a0 (reloaded) */\n        int qa0;   /* D_801838E0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801838E0 -> $a2 (reloaded) */\n        qb = (u16 *)D_801838DC;\n        qa = (u16 *)D_801838E0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801BB090))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801838E0;\n    extern s16 * D_801838DC;\n    extern u8 D_801838E8;\n    extern s16 *D_801838E4;\n    extern u16 D_801BB0A0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801838E0;\n\n    ax = ((u16 *)p2)[0]; pac = D_801838DC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801838E8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801BB0A0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801BB090)) {\n    found:\n        pb4 = (*(u16 * *)&D_801838E4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801BB0A0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801838DC -> $a0 (reloaded) */\n        int qa0;   /* D_801838E0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801838E0 -> $a2 (reloaded) */\n        qb = (u16 *)D_801838DC;\n        qa = (u16 *)D_801838E0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801BB090))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:37", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182AF4;\n    extern s16 * D_80182AF0;\n    extern u8 D_80182AFC;\n    extern s16 *D_80182AF8;\n    extern u16 D_801AB698;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80182AF4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80182AF0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80182AFC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80182AF4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80182AF0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182AFC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801AB688;\n    D_801AB698 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182AF8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801AB698;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182AF0 -> $a0 (reloaded) */\n        int qa0;   /* D_80182AF4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182AF4 -> $a2 (reloaded) */\n        qb = (u16 *)D_80182AF0;\n        qa = (u16 *)D_80182AF4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801AB688))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182AF4;\n    extern s16 * D_80182AF0;\n    extern u8 D_80182AFC;\n    extern s16 *D_80182AF8;\n    extern u16 D_801AB698;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80182AF4;\n\n    ax = ((u16 *)p2)[0]; pac = D_80182AF0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182AFC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801AB698 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801AB688)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182AF8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801AB698;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182AF0 -> $a0 (reloaded) */\n        int qa0;   /* D_80182AF4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182AF4 -> $a2 (reloaded) */\n        qb = (u16 *)D_80182AF0;\n        qa = (u16 *)D_80182AF4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801AB688))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:37", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80181C00;\n    extern s16 * D_80181BFC;\n    extern u8 D_80181C08;\n    extern s16 *D_80181C04;\n    extern u16 D_8019DD10;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80181C00 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80181BFC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80181C08 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80181C00;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80181BFC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181C08); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019DD00;\n    D_8019DD10 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80181C04);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019DD10;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80181BFC -> $a0 (reloaded) */\n        int qa0;   /* D_80181C00[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80181C00 -> $a2 (reloaded) */\n        qb = (u16 *)D_80181BFC;\n        qa = (u16 *)D_80181C00;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019DD00))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80181C00;\n    extern s16 * D_80181BFC;\n    extern u8 D_80181C08;\n    extern s16 *D_80181C04;\n    extern u16 D_8019DD10;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80181C00;\n\n    ax = ((u16 *)p2)[0]; pac = D_80181BFC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181C08); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019DD10 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019DD00)) {\n    found:\n        pb4 = (*(u16 * *)&D_80181C04);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019DD10;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80181BFC -> $a0 (reloaded) */\n        int qa0;   /* D_80181C00[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80181C00 -> $a2 (reloaded) */\n        qb = (u16 *)D_80181BFC;\n        qa = (u16 *)D_80181C00;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019DD00))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:37", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185FFC;\n    extern s16 * D_80185FF8;\n    extern u8 D_80186004;\n    extern s16 *D_80186000;\n    extern u16 D_801B48E8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80185FFC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80185FF8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80186004 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80185FFC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80185FF8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186004); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B48D8;\n    D_801B48E8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186000);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B48E8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185FF8 -> $a0 (reloaded) */\n        int qa0;   /* D_80185FFC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185FFC -> $a2 (reloaded) */\n        qb = (u16 *)D_80185FF8;\n        qa = (u16 *)D_80185FFC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B48D8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185FFC;\n    extern s16 * D_80185FF8;\n    extern u8 D_80186004;\n    extern s16 *D_80186000;\n    extern u16 D_801B48E8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80185FFC;\n\n    ax = ((u16 *)p2)[0]; pac = D_80185FF8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186004); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B48E8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B48D8)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186000);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B48E8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185FF8 -> $a0 (reloaded) */\n        int qa0;   /* D_80185FFC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185FFC -> $a2 (reloaded) */\n        qb = (u16 *)D_80185FF8;\n        qa = (u16 *)D_80185FFC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B48D8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:38", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801829D4;\n    extern s16 * D_801829D0;\n    extern u8 D_801829DC;\n    extern s16 *D_801829D8;\n    extern u16 D_801B0978;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801829D4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801829D0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801829DC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801829D4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801829D0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801829DC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B0968;\n    D_801B0978 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801829D8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B0978;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801829D0 -> $a0 (reloaded) */\n        int qa0;   /* D_801829D4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801829D4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801829D0;\n        qa = (u16 *)D_801829D4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B0968))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801829D4;\n    extern s16 * D_801829D0;\n    extern u8 D_801829DC;\n    extern s16 *D_801829D8;\n    extern u16 D_801B0978;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801829D4;\n\n    ax = ((u16 *)p2)[0]; pac = D_801829D0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801829DC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B0978 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B0968)) {\n    found:\n        pb4 = (*(u16 * *)&D_801829D8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B0978;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801829D0 -> $a0 (reloaded) */\n        int qa0;   /* D_801829D4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801829D4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801829D0;\n        qa = (u16 *)D_801829D4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B0968))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:38", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F9F4;\n    extern s16 * D_8017F9F0;\n    extern u8 D_8017F9FC;\n    extern s16 *D_8017F9F8;\n    extern u16 D_8018EAB0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017F9F4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017F9F0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017F9FC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017F9F4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017F9F0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F9FC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018EAA0;\n    D_8018EAB0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F9F8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8018EAB0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F9F0 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F9F4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F9F4 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F9F0;\n        qa = (u16 *)D_8017F9F4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8018EAA0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F9F4;\n    extern s16 * D_8017F9F0;\n    extern u8 D_8017F9FC;\n    extern s16 *D_8017F9F8;\n    extern u16 D_8018EAB0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017F9F4;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017F9F0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F9FC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8018EAB0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8018EAA0)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F9F8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8018EAB0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F9F0 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F9F4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F9F4 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F9F0;\n        qa = (u16 *)D_8017F9F4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8018EAA0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:38", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801807BC;\n    extern s16 * D_801807B8;\n    extern u8 D_801807C4;\n    extern s16 *D_801807C0;\n    extern u16 D_8019EB88;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801807BC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_801807B8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801807C4 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801807BC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_801807B8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801807C4); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019EB78;\n    D_8019EB88 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801807C0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019EB88;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801807B8 -> $a0 (reloaded) */\n        int qa0;   /* D_801807BC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801807BC -> $a2 (reloaded) */\n        qb = (u16 *)D_801807B8;\n        qa = (u16 *)D_801807BC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019EB78))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801807BC;\n    extern s16 * D_801807B8;\n    extern u8 D_801807C4;\n    extern s16 *D_801807C0;\n    extern u16 D_8019EB88;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801807BC;\n\n    ax = ((u16 *)p2)[0]; pac = D_801807B8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801807C4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019EB88 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019EB78)) {\n    found:\n        pb4 = (*(u16 * *)&D_801807C0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019EB88;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801807B8 -> $a0 (reloaded) */\n        int qa0;   /* D_801807BC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801807BC -> $a2 (reloaded) */\n        qb = (u16 *)D_801807B8;\n        qa = (u16 *)D_801807BC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019EB78))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:39", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F058;\n    extern s16 * D_8017F054;\n    extern u8 D_8017F060;\n    extern s16 *D_8017F05C;\n    extern u16 D_80190C30;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017F058 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017F054 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017F060 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017F058;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017F054; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80190C20;\n    D_80190C30 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F05C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80190C30;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F054 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F058[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F058 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F054;\n        qa = (u16 *)D_8017F058;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80190C20))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F058;\n    extern s16 * D_8017F054;\n    extern u8 D_8017F060;\n    extern s16 *D_8017F05C;\n    extern u16 D_80190C30;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017F058;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017F054; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_80190C30 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80190C20)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F05C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80190C30;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F054 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F058[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F058 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F054;\n        qa = (u16 *)D_8017F058;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80190C20))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:39", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F058;\n    extern s16 * D_8017F054;\n    extern u8 D_8017F060;\n    extern s16 *D_8017F05C;\n    extern u16 D_801957D0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017F058 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017F054 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017F060 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017F058;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017F054; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801957C0;\n    D_801957D0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F05C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801957D0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F054 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F058[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F058 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F054;\n        qa = (u16 *)D_8017F058;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801957C0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F058;\n    extern s16 * D_8017F054;\n    extern u8 D_8017F060;\n    extern s16 *D_8017F05C;\n    extern u16 D_801957D0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017F058;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017F054; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801957D0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801957C0)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F05C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801957D0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F054 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F058[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F058 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F054;\n        qa = (u16 *)D_8017F058;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801957C0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:39", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80180FF0;\n    extern s16 * D_80180FEC;\n    extern u8 D_80180FF8;\n    extern s16 *D_80180FF4;\n    extern u16 D_8019BA90;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80180FF0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80180FEC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80180FF8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80180FF0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80180FEC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180FF8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019BA80;\n    D_8019BA90 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80180FF4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019BA90;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80180FEC -> $a0 (reloaded) */\n        int qa0;   /* D_80180FF0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80180FF0 -> $a2 (reloaded) */\n        qb = (u16 *)D_80180FEC;\n        qa = (u16 *)D_80180FF0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019BA80))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80180FF0;\n    extern s16 * D_80180FEC;\n    extern u8 D_80180FF8;\n    extern s16 *D_80180FF4;\n    extern u16 D_8019BA90;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80180FF0;\n\n    ax = ((u16 *)p2)[0]; pac = D_80180FEC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180FF8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019BA90 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019BA80)) {\n    found:\n        pb4 = (*(u16 * *)&D_80180FF4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019BA90;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80180FEC -> $a0 (reloaded) */\n        int qa0;   /* D_80180FF0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80180FF0 -> $a2 (reloaded) */\n        qb = (u16 *)D_80180FEC;\n        qa = (u16 *)D_80180FF0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019BA80))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:40", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.47, "objects": ["build/src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.o", "build/src/ov_SC04_019/ov_SC04_019_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018D7A8;\n    extern s16 * D_8018D7A4;\n    extern u8 D_8018D7B0;\n    extern s16 *D_8018D7AC;\n    extern u16 D_801E5A90;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018D7A8 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_8018D7A4 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018D7B0 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018D7A8;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_8018D7A4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018D7B0); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E5A80;\n    D_801E5A90 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018D7AC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E5A90;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018D7A4 -> $a0 (reloaded) */\n        int qa0;   /* D_8018D7A8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018D7A8 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018D7A4;\n        qa = (u16 *)D_8018D7A8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E5A80))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018D7A8;\n    extern s16 * D_8018D7A4;\n    extern u8 D_8018D7B0;\n    extern s16 *D_8018D7AC;\n    extern u16 D_801E5A90;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018D7A8;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018D7A4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018D7B0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801E5A90 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801E5A80)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018D7AC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E5A90;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018D7A4 -> $a0 (reloaded) */\n        int qa0;   /* D_8018D7A8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018D7A8 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018D7A4;\n        qa = (u16 *)D_8018D7A8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E5A80))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:40", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182F48;\n    extern s16 * D_80182F44;\n    extern u8 D_80182F50;\n    extern s16 *D_80182F4C;\n    extern u16 D_8019FDC0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80182F48 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80182F44 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80182F50 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80182F48;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80182F44; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182F50); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019FDB0;\n    D_8019FDC0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182F4C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019FDC0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182F44 -> $a0 (reloaded) */\n        int qa0;   /* D_80182F48[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182F48 -> $a2 (reloaded) */\n        qb = (u16 *)D_80182F44;\n        qa = (u16 *)D_80182F48;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019FDB0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182F48;\n    extern s16 * D_80182F44;\n    extern u8 D_80182F50;\n    extern s16 *D_80182F4C;\n    extern u16 D_8019FDC0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80182F48;\n\n    ax = ((u16 *)p2)[0]; pac = D_80182F44; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182F50); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019FDC0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019FDB0)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182F4C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019FDC0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182F44 -> $a0 (reloaded) */\n        int qa0;   /* D_80182F48[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182F48 -> $a2 (reloaded) */\n        qb = (u16 *)D_80182F44;\n        qa = (u16 *)D_80182F48;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019FDB0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:40", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80188F34;\n    extern s16 * D_80188F30;\n    extern u8 D_80188F3C;\n    extern s16 *D_80188F38;\n    extern u16 D_801C5C20;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80188F34 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pac __asm__(\"$6\");   /* D_80188F30 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80188F3C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A tus1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80188F34;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A tus1)\n\n    a = ((u16 *)p2)[0]; pac = D_80188F30; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80188F3C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801C5C10;\n    D_801C5C20 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80188F38);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C5C20;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80188F30 -> $a0 (reloaded) */\n        int qa0;   /* D_80188F34[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80188F34 -> $a2 (reloaded) */\n        qb = (u16 *)D_80188F30;\n        qa = (u16 *)D_80188F34;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C5C10))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80188F34;\n    extern s16 * D_80188F30;\n    extern u8 D_80188F3C;\n    extern s16 *D_80188F38;\n    extern u16 D_801C5C20;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80188F34;\n\n    ax = ((u16 *)p2)[0]; pac = D_80188F30; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80188F3C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801C5C20 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801C5C10)) {\n    found:\n        pb4 = (*(u16 * *)&D_80188F38);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801C5C20;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80188F30 -> $a0 (reloaded) */\n        int qa0;   /* D_80188F34[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80188F34 -> $a2 (reloaded) */\n        qb = (u16 *)D_80188F30;\n        qa = (u16 *)D_80188F34;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801C5C10))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:41", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80193B68;\n    extern s16 * D_80193B64;\n    extern u8 D_80193B70;\n    extern s16 *D_80193B6C;\n    extern u16 D_801D3C58;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80193B68 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_80193B64 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80193B70 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80193B68;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_80193B64; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80193B70); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801D3C48;\n    D_801D3C58 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80193B6C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D3C58;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80193B64 -> $a0 (reloaded) */\n        int qa0;   /* D_80193B68[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80193B68 -> $a2 (reloaded) */\n        qb = (u16 *)D_80193B64;\n        qa = (u16 *)D_80193B68;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D3C48))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80193B68;\n    extern s16 * D_80193B64;\n    extern u8 D_80193B70;\n    extern s16 *D_80193B6C;\n    extern u16 D_801D3C58;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80193B68;\n\n    ax = ((u16 *)p2)[0]; pac = D_80193B64; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80193B70); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801D3C58 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801D3C48)) {\n    found:\n        pb4 = (*(u16 * *)&D_80193B6C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801D3C58;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80193B64 -> $a0 (reloaded) */\n        int qa0;   /* D_80193B68[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80193B68 -> $a2 (reloaded) */\n        qb = (u16 *)D_80193B64;\n        qa = (u16 *)D_80193B68;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801D3C48))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:41", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E2AC;\n    extern s16 * D_8017E2A8;\n    extern u8 D_8017E2B4;\n    extern s16 *D_8017E2B0;\n    extern u16 D_8019BDA8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017E2AC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_8017E2A8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017E2B4 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017E2AC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_8017E2A8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E2B4); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019BD98;\n    D_8019BDA8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E2B0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019BDA8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E2A8 -> $a0 (reloaded) */\n        int qa0;   /* D_8017E2AC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E2AC -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E2A8;\n        qa = (u16 *)D_8017E2AC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019BD98))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E2AC;\n    extern s16 * D_8017E2A8;\n    extern u8 D_8017E2B4;\n    extern s16 *D_8017E2B0;\n    extern u16 D_8019BDA8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017E2AC;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017E2A8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E2B4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019BDA8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019BD98)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E2B0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019BDA8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E2A8 -> $a0 (reloaded) */\n        int qa0;   /* D_8017E2AC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E2AC -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E2A8;\n        qa = (u16 *)D_8017E2AC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019BD98))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:41", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.236, "objects": ["build/src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182340;\n    extern s16 * D_8018233C;\n    extern u8 D_80182348;\n    extern s16 *D_80182344;\n    extern u16 D_801F6DB0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80182340 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_8018233C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80182348 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80182340;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_8018233C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182348); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801F6DA0;\n    D_801F6DB0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182344);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801F6DB0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018233C -> $a0 (reloaded) */\n        int qa0;   /* D_80182340[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182340 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018233C;\n        qa = (u16 *)D_80182340;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801F6DA0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182340;\n    extern s16 * D_8018233C;\n    extern u8 D_80182348;\n    extern s16 *D_80182344;\n    extern u16 D_801F6DB0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80182340;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018233C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182348); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801F6DB0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801F6DA0)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182344);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801F6DB0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018233C -> $a0 (reloaded) */\n        int qa0;   /* D_80182340[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182340 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018233C;\n        qa = (u16 *)D_80182340;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801F6DA0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:42", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018D76C;\n    extern s16 * D_8018D768;\n    extern u8 D_8018D774;\n    extern s16 *D_8018D770;\n    extern u16 D_801EB8E8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018D76C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_8018D768 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018D774 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018D76C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_8018D768; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018D774); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801EB8D8;\n    D_801EB8E8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018D770);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801EB8E8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018D768 -> $a0 (reloaded) */\n        int qa0;   /* D_8018D76C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018D76C -> $a2 (reloaded) */\n        qb = (u16 *)D_8018D768;\n        qa = (u16 *)D_8018D76C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801EB8D8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018D76C;\n    extern s16 * D_8018D768;\n    extern u8 D_8018D774;\n    extern s16 *D_8018D770;\n    extern u16 D_801EB8E8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018D76C;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018D768; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018D774); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801EB8E8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801EB8D8)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018D770);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801EB8E8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018D768 -> $a0 (reloaded) */\n        int qa0;   /* D_8018D76C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018D76C -> $a2 (reloaded) */\n        qb = (u16 *)D_8018D768;\n        qa = (u16 *)D_8018D76C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801EB8D8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:42", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186EC8;\n    extern s16 * D_80186EC4;\n    extern u8 D_80186ED0;\n    extern s16 *D_80186ECC;\n    extern u16 D_801E5028;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80186EC8 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_80186EC4 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80186ED0 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80186EC8;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_80186EC4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186ED0); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E5018;\n    D_801E5028 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186ECC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E5028;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186EC4 -> $a0 (reloaded) */\n        int qa0;   /* D_80186EC8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186EC8 -> $a2 (reloaded) */\n        qb = (u16 *)D_80186EC4;\n        qa = (u16 *)D_80186EC8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E5018))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186EC8;\n    extern s16 * D_80186EC4;\n    extern u8 D_80186ED0;\n    extern s16 *D_80186ECC;\n    extern u16 D_801E5028;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80186EC8;\n\n    ax = ((u16 *)p2)[0]; pac = D_80186EC4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186ED0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801E5028 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801E5018)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186ECC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E5028;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186EC4 -> $a0 (reloaded) */\n        int qa0;   /* D_80186EC8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186EC8 -> $a2 (reloaded) */\n        qb = (u16 *)D_80186EC4;\n        qa = (u16 *)D_80186EC8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E5018))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:42", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.237, "objects": ["build/src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185DA8;\n    extern s16 * D_80185DA4;\n    extern u8 D_80185DB0;\n    extern s16 *D_80185DAC;\n    extern u16 D_801A8D30;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80185DA8 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_80185DA4 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80185DB0 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80185DA8;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_80185DA4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185DB0); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A8D20;\n    D_801A8D30 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185DAC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A8D30;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185DA4 -> $a0 (reloaded) */\n        int qa0;   /* D_80185DA8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185DA8 -> $a2 (reloaded) */\n        qb = (u16 *)D_80185DA4;\n        qa = (u16 *)D_80185DA8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A8D20))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185DA8;\n    extern s16 * D_80185DA4;\n    extern u8 D_80185DB0;\n    extern s16 *D_80185DAC;\n    extern u16 D_801A8D30;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80185DA8;\n\n    ax = ((u16 *)p2)[0]; pac = D_80185DA4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185DB0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A8D30 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A8D20)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185DAC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A8D30;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185DA4 -> $a0 (reloaded) */\n        int qa0;   /* D_80185DA8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185DA8 -> $a2 (reloaded) */\n        qb = (u16 *)D_80185DA4;\n        qa = (u16 *)D_80185DA8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A8D20))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:43", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F160;\n    extern s16 * D_8017F15C;\n    extern u8 D_8017F168;\n    extern s16 *D_8017F164;\n    extern u16 D_801997D0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017F160 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_8017F15C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017F168 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017F160;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_8017F15C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F168); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801997C0;\n    D_801997D0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F164);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801997D0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F15C -> $a0 (reloaded) */\n        int qa0;   /* D_8017F160[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F160 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F15C;\n        qa = (u16 *)D_8017F160;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801997C0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F160;\n    extern s16 * D_8017F15C;\n    extern u8 D_8017F168;\n    extern s16 *D_8017F164;\n    extern u16 D_801997D0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017F160;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017F15C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F168); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801997D0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801997C0)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F164);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801997D0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F15C -> $a0 (reloaded) */\n        int qa0;   /* D_8017F160[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F160 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F15C;\n        qa = (u16 *)D_8017F160;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801997C0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:43", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.231, "objects": ["build/src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801809E4;\n    extern s16 * D_801809E0;\n    extern u8 D_801809EC;\n    extern s16 *D_801809E8;\n    extern u16 D_801AA918;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801809E4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_801809E0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801809EC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801809E4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_801809E0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801809EC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801AA908;\n    D_801AA918 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801809E8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801AA918;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801809E0 -> $a0 (reloaded) */\n        int qa0;   /* D_801809E4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801809E4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801809E0;\n        qa = (u16 *)D_801809E4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801AA908))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801809E4;\n    extern s16 * D_801809E0;\n    extern u8 D_801809EC;\n    extern s16 *D_801809E8;\n    extern u16 D_801AA918;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801809E4;\n\n    ax = ((u16 *)p2)[0]; pac = D_801809E0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801809EC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801AA918 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801AA908)) {\n    found:\n        pb4 = (*(u16 * *)&D_801809E8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801AA918;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801809E0 -> $a0 (reloaded) */\n        int qa0;   /* D_801809E4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801809E4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801809E0;\n        qa = (u16 *)D_801809E4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801AA908))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:43", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018881C;\n    extern s16 * D_80188818;\n    extern u8 D_80188824;\n    extern s16 *D_80188820;\n    extern u16 D_801AD368;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018881C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_80188818 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80188824 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018881C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_80188818; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80188824); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801AD358;\n    D_801AD368 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80188820);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801AD368;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80188818 -> $a0 (reloaded) */\n        int qa0;   /* D_8018881C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018881C -> $a2 (reloaded) */\n        qb = (u16 *)D_80188818;\n        qa = (u16 *)D_8018881C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801AD358))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018881C;\n    extern s16 * D_80188818;\n    extern u8 D_80188824;\n    extern s16 *D_80188820;\n    extern u16 D_801AD368;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018881C;\n\n    ax = ((u16 *)p2)[0]; pac = D_80188818; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80188824); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801AD368 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801AD358)) {\n    found:\n        pb4 = (*(u16 * *)&D_80188820);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801AD368;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80188818 -> $a0 (reloaded) */\n        int qa0;   /* D_8018881C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018881C -> $a2 (reloaded) */\n        qb = (u16 *)D_80188818;\n        qa = (u16 *)D_8018881C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801AD358))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:44", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186F84;\n    extern s16 * D_80186F80;\n    extern u8 D_80186F8C;\n    extern s16 *D_80186F88;\n    extern u16 D_801B0D68;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80186F84 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_80186F80 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80186F8C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80186F84;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_80186F80; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186F8C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B0D58;\n    D_801B0D68 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186F88);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B0D68;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186F80 -> $a0 (reloaded) */\n        int qa0;   /* D_80186F84[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186F84 -> $a2 (reloaded) */\n        qb = (u16 *)D_80186F80;\n        qa = (u16 *)D_80186F84;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B0D58))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186F84;\n    extern s16 * D_80186F80;\n    extern u8 D_80186F8C;\n    extern s16 *D_80186F88;\n    extern u16 D_801B0D68;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80186F84;\n\n    ax = ((u16 *)p2)[0]; pac = D_80186F80; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186F8C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B0D68 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B0D58)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186F88);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B0D68;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186F80 -> $a0 (reloaded) */\n        int qa0;   /* D_80186F84[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186F84 -> $a2 (reloaded) */\n        qb = (u16 *)D_80186F80;\n        qa = (u16 *)D_80186F84;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B0D58))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:44", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801804C4;\n    extern s16 * D_801804C0;\n    extern u8 D_801804CC;\n    extern s16 *D_801804C8;\n    extern u16 D_801A01C0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801804C4 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_801804C0 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801804CC -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801804C4;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_801804C0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801804CC); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A01B0;\n    D_801A01C0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801804C8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A01C0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801804C0 -> $a0 (reloaded) */\n        int qa0;   /* D_801804C4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801804C4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801804C0;\n        qa = (u16 *)D_801804C4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A01B0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801804C4;\n    extern s16 * D_801804C0;\n    extern u8 D_801804CC;\n    extern s16 *D_801804C8;\n    extern u16 D_801A01C0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801804C4;\n\n    ax = ((u16 *)p2)[0]; pac = D_801804C0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801804CC); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A01C0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A01B0)) {\n    found:\n        pb4 = (*(u16 * *)&D_801804C8);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A01C0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801804C0 -> $a0 (reloaded) */\n        int qa0;   /* D_801804C4[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801804C4 -> $a2 (reloaded) */\n        qb = (u16 *)D_801804C0;\n        qa = (u16 *)D_801804C4;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A01B0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:44", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.24, "objects": ["build/src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F01C;\n    extern s16 * D_8017F018;\n    extern u8 D_8017F024;\n    extern s16 *D_8017F020;\n    extern u16 D_801935A0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017F01C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_8017F018 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017F024 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017F01C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_8017F018; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F024); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80193590;\n    D_801935A0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F020);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801935A0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F018 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F01C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F01C -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F018;\n        qa = (u16 *)D_8017F01C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80193590))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F01C;\n    extern s16 * D_8017F018;\n    extern u8 D_8017F024;\n    extern s16 *D_8017F020;\n    extern u16 D_801935A0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017F01C;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017F018; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F024); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801935A0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80193590)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F020);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801935A0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F018 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F01C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F01C -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F018;\n        qa = (u16 *)D_8017F01C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80193590))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:45", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018542C;\n    extern s16 * D_80185428;\n    extern u8 D_80185434;\n    extern s16 *D_80185430;\n    extern u16 D_8019E370;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018542C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_80185428 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80185434 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018542C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_80185428; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185434); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019E360;\n    D_8019E370 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185430);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019E370;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185428 -> $a0 (reloaded) */\n        int qa0;   /* D_8018542C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018542C -> $a2 (reloaded) */\n        qb = (u16 *)D_80185428;\n        qa = (u16 *)D_8018542C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019E360))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018542C;\n    extern s16 * D_80185428;\n    extern u8 D_80185434;\n    extern s16 *D_80185430;\n    extern u16 D_8019E370;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018542C;\n\n    ax = ((u16 *)p2)[0]; pac = D_80185428; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185434); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019E370 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019E360)) {\n    found:\n        pb4 = (*(u16 * *)&D_80185430);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019E370;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185428 -> $a0 (reloaded) */\n        int qa0;   /* D_8018542C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018542C -> $a2 (reloaded) */\n        qb = (u16 *)D_80185428;\n        qa = (u16 *)D_8018542C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019E360))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:45", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018D8AC;\n    extern s16 * D_8018D8A8;\n    extern u8 D_8018D8B4;\n    extern s16 *D_8018D8B0;\n    extern u16 D_801E0CD8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018D8AC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_8018D8A8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018D8B4 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018D8AC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_8018D8A8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018D8B4); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801E0CC8;\n    D_801E0CD8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018D8B0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E0CD8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018D8A8 -> $a0 (reloaded) */\n        int qa0;   /* D_8018D8AC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018D8AC -> $a2 (reloaded) */\n        qb = (u16 *)D_8018D8A8;\n        qa = (u16 *)D_8018D8AC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E0CC8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018D8AC;\n    extern s16 * D_8018D8A8;\n    extern u8 D_8018D8B4;\n    extern s16 *D_8018D8B0;\n    extern u16 D_801E0CD8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018D8AC;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018D8A8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018D8B4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801E0CD8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801E0CC8)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018D8B0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801E0CD8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018D8A8 -> $a0 (reloaded) */\n        int qa0;   /* D_8018D8AC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018D8AC -> $a2 (reloaded) */\n        qb = (u16 *)D_8018D8A8;\n        qa = (u16 *)D_8018D8AC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801E0CC8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:45", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801855F0;\n    extern s16 * D_801855EC;\n    extern u8 D_801855F8;\n    extern s16 *D_801855F4;\n    extern u16 D_801B9470;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801855F0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pac __asm__(\"$6\");   /* D_801855EC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801855F8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus3)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801855F0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus3)\n\n    a = ((u16 *)p2)[0]; pac = D_801855EC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801855F8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B9460;\n    D_801B9470 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801855F4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B9470;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801855EC -> $a0 (reloaded) */\n        int qa0;   /* D_801855F0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801855F0 -> $a2 (reloaded) */\n        qb = (u16 *)D_801855EC;\n        qa = (u16 *)D_801855F0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B9460))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801855F0;\n    extern s16 * D_801855EC;\n    extern u8 D_801855F8;\n    extern s16 *D_801855F4;\n    extern u16 D_801B9470;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801855F0;\n\n    ax = ((u16 *)p2)[0]; pac = D_801855EC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801855F8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B9470 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B9460)) {\n    found:\n        pb4 = (*(u16 * *)&D_801855F4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B9470;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801855EC -> $a0 (reloaded) */\n        int qa0;   /* D_801855F0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801855F0 -> $a2 (reloaded) */\n        qb = (u16 *)D_801855EC;\n        qa = (u16 *)D_801855F0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B9460))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:46", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185228;\n    extern s16 * D_80185224;\n    extern u8 D_80185230;\n    extern s16 *D_8018522C;\n    extern u16 D_801B0020;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80185228 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");   /* D_80185224 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80185230 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80185228;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = ((u16 *)p2)[0]; pac = D_80185224; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185230); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B0010;\n    D_801B0020 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018522C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B0020;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185224 -> $a0 (reloaded) */\n        int qa0;   /* D_80185228[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185228 -> $a2 (reloaded) */\n        qb = (u16 *)D_80185224;\n        qa = (u16 *)D_80185228;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B0010))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80185228;\n    extern s16 * D_80185224;\n    extern u8 D_80185230;\n    extern s16 *D_8018522C;\n    extern u16 D_801B0020;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80185228;\n\n    ax = ((u16 *)p2)[0]; pac = D_80185224; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185230); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B0020 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B0010)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018522C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B0020;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80185224 -> $a0 (reloaded) */\n        int qa0;   /* D_80185228[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80185228 -> $a2 (reloaded) */\n        qb = (u16 *)D_80185224;\n        qa = (u16 *)D_80185228;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B0010))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:46", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801823EC;\n    extern s16 * D_801823E8;\n    extern u8 D_801823F4;\n    extern s16 *D_801823F0;\n    extern u16 D_801B8B78;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801823EC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");   /* D_801823E8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801823F4 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801823EC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = ((u16 *)p2)[0]; pac = D_801823E8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801823F4); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8B68;\n    D_801B8B78 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801823F0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B8B78;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801823E8 -> $a0 (reloaded) */\n        int qa0;   /* D_801823EC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801823EC -> $a2 (reloaded) */\n        qb = (u16 *)D_801823E8;\n        qa = (u16 *)D_801823EC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B8B68))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801823EC;\n    extern s16 * D_801823E8;\n    extern u8 D_801823F4;\n    extern s16 *D_801823F0;\n    extern u16 D_801B8B78;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801823EC;\n\n    ax = ((u16 *)p2)[0]; pac = D_801823E8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801823F4); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801B8B78 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801B8B68)) {\n    found:\n        pb4 = (*(u16 * *)&D_801823F0);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801B8B78;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801823E8 -> $a0 (reloaded) */\n        int qa0;   /* D_801823EC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801823EC -> $a2 (reloaded) */\n        qb = (u16 *)D_801823E8;\n        qa = (u16 *)D_801823EC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801B8B68))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:46", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80191DC8;\n    extern s16 * D_80191DC4;\n    extern u8 D_80191DD0;\n    extern s16 *D_80191DCC;\n    extern u16 D_801CF2E8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80191DC8 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");   /* D_80191DC4 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80191DD0 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80191DC8;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = ((u16 *)p2)[0]; pac = D_80191DC4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80191DD0); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CF2D8;\n    D_801CF2E8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80191DCC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CF2E8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80191DC4 -> $a0 (reloaded) */\n        int qa0;   /* D_80191DC8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80191DC8 -> $a2 (reloaded) */\n        qb = (u16 *)D_80191DC4;\n        qa = (u16 *)D_80191DC8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CF2D8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80191DC8;\n    extern s16 * D_80191DC4;\n    extern u8 D_80191DD0;\n    extern s16 *D_80191DCC;\n    extern u16 D_801CF2E8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80191DC8;\n\n    ax = ((u16 *)p2)[0]; pac = D_80191DC4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80191DD0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801CF2E8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801CF2D8)) {\n    found:\n        pb4 = (*(u16 * *)&D_80191DCC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CF2E8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80191DC4 -> $a0 (reloaded) */\n        int qa0;   /* D_80191DC8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80191DC8 -> $a2 (reloaded) */\n        qb = (u16 *)D_80191DC4;\n        qa = (u16 *)D_80191DC8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CF2D8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:46", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018CAFC;\n    extern s16 * D_8018CAF8;\n    extern u8 D_8018CB04;\n    extern s16 *D_8018CB00;\n    extern u16 D_801DB918;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018CAFC -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");   /* D_8018CAF8 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018CB04 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018CAFC;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = ((u16 *)p2)[0]; pac = D_8018CAF8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018CB04); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801DB908;\n    D_801DB918 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018CB00);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801DB918;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018CAF8 -> $a0 (reloaded) */\n        int qa0;   /* D_8018CAFC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018CAFC -> $a2 (reloaded) */\n        qb = (u16 *)D_8018CAF8;\n        qa = (u16 *)D_8018CAFC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801DB908))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018CAFC;\n    extern s16 * D_8018CAF8;\n    extern u8 D_8018CB04;\n    extern s16 *D_8018CB00;\n    extern u16 D_801DB918;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018CAFC;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018CAF8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018CB04); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801DB918 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801DB908)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018CB00);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801DB918;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018CAF8 -> $a0 (reloaded) */\n        int qa0;   /* D_8018CAFC[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018CAFC -> $a2 (reloaded) */\n        qb = (u16 *)D_8018CAF8;\n        qa = (u16 *)D_8018CAFC;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801DB908))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:47", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.235, "objects": ["build/src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E568;\n    extern s16 * D_8017E564;\n    extern u8 D_8017E570;\n    extern s16 *D_8017E56C;\n    extern u16 D_8019BFF8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017E568 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");   /* D_8017E564 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017E570 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017E568;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = ((u16 *)p2)[0]; pac = D_8017E564; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E570); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019BFE8;\n    D_8019BFF8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E56C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019BFF8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E564 -> $a0 (reloaded) */\n        int qa0;   /* D_8017E568[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E568 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E564;\n        qa = (u16 *)D_8017E568;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019BFE8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E568;\n    extern s16 * D_8017E564;\n    extern u8 D_8017E570;\n    extern s16 *D_8017E56C;\n    extern u16 D_8019BFF8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017E568;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017E564; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E570); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019BFF8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019BFE8)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E56C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019BFF8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E564 -> $a0 (reloaded) */\n        int qa0;   /* D_8017E568[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E568 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E564;\n        qa = (u16 *)D_8017E568;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019BFE8))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:47", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.231, "objects": ["build/src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018FD84;\n    extern s16 * D_8018FD80;\n    extern u8 D_8018FD8C;\n    extern s16 *D_8018FD88;\n    extern u16 D_801DFE58;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8018FD84 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");   /* D_8018FD80 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8018FD8C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8018FD84;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = ((u16 *)p2)[0]; pac = D_8018FD80; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018FD8C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801DFE48;\n    D_801DFE58 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018FD88);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801DFE58;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018FD80 -> $a0 (reloaded) */\n        int qa0;   /* D_8018FD84[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018FD84 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018FD80;\n        qa = (u16 *)D_8018FD84;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801DFE48))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8018FD84;\n    extern s16 * D_8018FD80;\n    extern u8 D_8018FD8C;\n    extern s16 *D_8018FD88;\n    extern u16 D_801DFE58;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8018FD84;\n\n    ax = ((u16 *)p2)[0]; pac = D_8018FD80; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018FD8C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801DFE58 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801DFE48)) {\n    found:\n        pb4 = (*(u16 * *)&D_8018FD88);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801DFE58;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8018FD80 -> $a0 (reloaded) */\n        int qa0;   /* D_8018FD84[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8018FD84 -> $a2 (reloaded) */\n        qb = (u16 *)D_8018FD80;\n        qa = (u16 *)D_8018FD84;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801DFE48))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:47", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.233, "objects": ["build/src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801938B8;\n    extern s16 * D_801938B4;\n    extern u8 D_801938C0;\n    extern s16 *D_801938BC;\n    extern u16 D_801CF228;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_801938B8 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");   /* D_801938B4 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$8\");   /* D_801938C0 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_801938B8;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = ((u16 *)p2)[0]; pac = D_801938B4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801938C0); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CF218;\n    D_801CF228 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_801938BC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CF228;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801938B4 -> $a0 (reloaded) */\n        int qa0;   /* D_801938B8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801938B8 -> $a2 (reloaded) */\n        qb = (u16 *)D_801938B4;\n        qa = (u16 *)D_801938B8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CF218))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_801938B8;\n    extern s16 * D_801938B4;\n    extern u8 D_801938C0;\n    extern s16 *D_801938BC;\n    extern u16 D_801CF228;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_801938B8;\n\n    ax = ((u16 *)p2)[0]; pac = D_801938B4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801938C0); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801CF228 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801CF218)) {\n    found:\n        pb4 = (*(u16 * *)&D_801938BC);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CF228;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_801938B4 -> $a0 (reloaded) */\n        int qa0;   /* D_801938B8[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_801938B8 -> $a2 (reloaded) */\n        qb = (u16 *)D_801938B4;\n        qa = (u16 *)D_801938B8;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CF218))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:48", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182C10;\n    extern s16 * D_80182C0C;\n    extern u8 D_80182C18;\n    extern s16 *D_80182C14;\n    extern u16 D_801CE830;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80182C10 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");   /* D_80182C0C -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80182C18 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80182C10;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = ((u16 *)p2)[0]; pac = D_80182C0C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182C18); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801CE820;\n    D_801CE830 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182C14);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CE830;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182C0C -> $a0 (reloaded) */\n        int qa0;   /* D_80182C10[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182C10 -> $a2 (reloaded) */\n        qb = (u16 *)D_80182C0C;\n        qa = (u16 *)D_80182C10;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CE820))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80182C10;\n    extern s16 * D_80182C0C;\n    extern u8 D_80182C18;\n    extern s16 *D_80182C14;\n    extern u16 D_801CE830;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80182C10;\n\n    ax = ((u16 *)p2)[0]; pac = D_80182C0C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182C18); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801CE830 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801CE820)) {\n    found:\n        pb4 = (*(u16 * *)&D_80182C14);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801CE830;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80182C0C -> $a0 (reloaded) */\n        int qa0;   /* D_80182C10[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80182C10 -> $a2 (reloaded) */\n        qb = (u16 *)D_80182C0C;\n        qa = (u16 *)D_80182C10;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801CE820))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:48", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.238, "objects": ["build/src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80181AC0;\n    extern s16 * D_80181ABC;\n    extern u8 D_80181AC8;\n    extern s16 *D_80181AC4;\n    extern u16 D_801A98E0;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80181AC0 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");   /* D_80181ABC -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80181AC8 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80181AC0;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = ((u16 *)p2)[0]; pac = D_80181ABC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181AC8); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A98D0;\n    D_801A98E0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80181AC4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A98E0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80181ABC -> $a0 (reloaded) */\n        int qa0;   /* D_80181AC0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80181AC0 -> $a2 (reloaded) */\n        qb = (u16 *)D_80181ABC;\n        qa = (u16 *)D_80181AC0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A98D0))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80181AC0;\n    extern s16 * D_80181ABC;\n    extern u8 D_80181AC8;\n    extern s16 *D_80181AC4;\n    extern u16 D_801A98E0;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80181AC0;\n\n    ax = ((u16 *)p2)[0]; pac = D_80181ABC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181AC8); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A98E0 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A98D0)) {\n    found:\n        pb4 = (*(u16 * *)&D_80181AC4);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A98E0;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80181ABC -> $a0 (reloaded) */\n        int qa0;   /* D_80181AC0[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80181AC0 -> $a2 (reloaded) */\n        qb = (u16 *)D_80181ABC;\n        qa = (u16 *)D_80181AC0;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A98D0))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:48", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.239, "objects": ["build/src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017D894;\n    extern s16 * D_8017D890;\n    extern u8 D_8017D89C;\n    extern s16 *D_8017D898;\n    extern u16 D_80195318;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017D894 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");   /* D_8017D890 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017D89C -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017D894;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = ((u16 *)p2)[0]; pac = D_8017D890; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017D89C); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_80195308;\n    D_80195318 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017D898);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80195318;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017D890 -> $a0 (reloaded) */\n        int qa0;   /* D_8017D894[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017D894 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017D890;\n        qa = (u16 *)D_8017D894;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80195308))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017D894;\n    extern s16 * D_8017D890;\n    extern u8 D_8017D89C;\n    extern s16 *D_8017D898;\n    extern u16 D_80195318;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017D894;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017D890; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017D89C); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_80195318 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_80195308)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017D898);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_80195318;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017D890 -> $a0 (reloaded) */\n        int qa0;   /* D_8017D894[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017D894 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017D890;\n        qa = (u16 *)D_8017D894;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_80195308))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:49", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.234, "objects": ["build/src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E338;\n    extern s16 * D_8017E334;\n    extern u8 D_8017E340;\n    extern s16 *D_8017E33C;\n    extern u16 D_801A29A8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017E338 -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");   /* D_8017E334 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017E340 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017E338;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = ((u16 *)p2)[0]; pac = D_8017E334; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E340); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_801A2998;\n    D_801A29A8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E33C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A29A8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E334 -> $a0 (reloaded) */\n        int qa0;   /* D_8017E338[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E338 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E334;\n        qa = (u16 *)D_8017E338;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A2998))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017E338;\n    extern s16 * D_8017E334;\n    extern u8 D_8017E340;\n    extern s16 *D_8017E33C;\n    extern u16 D_801A29A8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017E338;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017E334; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E340); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_801A29A8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_801A2998)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017E33C);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_801A29A8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017E334 -> $a0 (reloaded) */\n        int qa0;   /* D_8017E338[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017E338 -> $a2 (reloaded) */\n        qb = (u16 *)D_8017E334;\n        qa = (u16 *)D_8017E338;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_801A2998))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:49", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.c", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": false, "includers": 0, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.232, "objects": ["build/src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186D7C;\n    extern s16 * D_80186D78;\n    extern u8 D_80186D84;\n    extern s16 *D_80186D80;\n    extern u16 D_8019A430;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_80186D7C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pac __asm__(\"$6\");   /* D_80186D78 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    register s16 *pb8 __asm__(\"$8\");   /* D_80186D84 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung B tus4)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_80186D7C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung B tus4)\n\n    a = ((u16 *)p2)[0]; pac = D_80186D78; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186D84); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8019A420;\n    D_8019A430 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186D80);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019A430;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186D78 -> $a0 (reloaded) */\n        int qa0;   /* D_80186D7C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186D7C -> $a2 (reloaded) */\n        qb = (u16 *)D_80186D78;\n        qa = (u16 *)D_80186D7C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019A420))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_80186D7C;\n    extern s16 * D_80186D78;\n    extern u8 D_80186D84;\n    extern s16 *D_80186D80;\n    extern u16 D_8019A430;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_80186D7C;\n\n    ax = ((u16 *)p2)[0]; pac = D_80186D78; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186D84); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8019A430 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8019A420)) {\n    found:\n        pb4 = (*(u16 * *)&D_80186D80);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8019A430;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_80186D78 -> $a0 (reloaded) */\n        int qa0;   /* D_80186D7C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_80186D7C -> $a2 (reloaded) */\n        qb = (u16 *)D_80186D78;\n        qa = (u16 *)D_80186D7C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8019A420))\n            goto found;\n        return 0;\n    }\n}\n"}
+{"ts": "2026-09-10 14:48:50", "label": "c8p", "rung": "E", "calib": {"head": "205331765", "stamp": "15956e4a96c4"}, "tu": "src/shared/ov/func_80135004__0f8f8d0b.h", "fn": "func_80135004", "addr": 2148749316, "aliases": null, "header": true, "includers": 3, "nhash_before": "415c8cc1515a1a85254c2ed7065af4b19d218559", "nhash_after": "84255a903577529ee712cdbc97647e719440dfd3", "source": "propagate:src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c:func_80135004", "verdict": "LEVER-FREE", "sites": [], "compiles": 3, "seconds": 0.705, "objects": ["build/src/ov_SC03_126/ov_SC03_126_jr_8012ACE0.o", "build/src/ov_SC04_021/ov_SC04_021_jr_8012ACE0.o", "build/src/ov_SC05_019/ov_SC05_019_jr_8012ACE0.o"], "before_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F80C;\n    extern s16 * D_8017F808;\n    extern u8 D_8017F814;\n    extern s16 *D_8017F810;\n    extern u16 D_8018E6F8;\n\n    register s16 *pb0 __asm__(\"$9\");   /* D_8017F80C -> $t1 */  // !FAKE: pin $9 \u2014 NEEDED DIFFERS (P36 rung A headers1)\n    register s16 *pac __asm__(\"$6\");   /* D_8017F808 -> $a2 */  // !FAKE: pin $6 \u2014 NEEDED DIFFERS (P36 rung A headers1)\n    register s16 *pb8 __asm__(\"$8\");   /* D_8017F814 -> $t0 */  // !FAKE: pin $8 \u2014 NEEDED DIFFERS (P36 rung A headers1)\n    u16 *pb4;\n    u16 a, b;\n    int id;\n    int a1v, a2v, d94;\n\n    pb0 = D_8017F80C;\n    __asm__ __volatile__(\"\" : : \"r\"(pb0));  // !FAKE: keepalive \u2014 NEEDED DIFFERS (P36 rung A headers1)\n\n    a = ((u16 *)p2)[0]; pac = D_8017F808; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F814); pac[0] = b; pb8[0] = a - b;\n    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;\n    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2]; d94 = D_8018E6E8;\n    D_8018E6F8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, d94)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F810);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8018E6F8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F808 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F80C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F80C -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F808;\n        qa = (u16 *)D_8017F80C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8018E6E8))\n            goto found;\n        return 0;\n    }\n}\n", "after_text": "s32 func_80135004(s32 arg0, s32 p1, s32 p2)\n{\n    extern int func_80134A74(int, s16, s16, int);\n    extern s16 * D_8017F80C;\n    extern s16 * D_8017F808;\n    extern u8 D_8017F814;\n    extern s16 *D_8017F810;\n    extern u16 D_8018E6F8;\n\n    s16 *pb0;\n    s16 *pac;\n    s16 *pb8;\n    u16 *pb4;\n    u16 ax, bx, ay, by, az, bz;\n    int id;\n    int a1v, a2v;\n\n    pb0 = D_8017F80C;\n\n    ax = ((u16 *)p2)[0]; pac = D_8017F808; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F814); pac[0] = bx; pb8[0] = ax - bx;\n    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;\n    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;\n\n    id = ((int)arg0) & 0xFFFF;\n    a1v = pac[0]; a2v = pac[2];\n    D_8018E6F8 = 0;\n\n    if (func_80134A74(id, a1v, a2v, D_8018E6E8)) {\n    found:\n        pb4 = (*(u16 * *)&D_8017F810);\n        ((u16 *)p2)[0] = pb4[0];\n        ((u16 *)p2)[1] = pb4[1];\n        ((u16 *)p2)[2] = pb4[2];\n        ((u16 *)p2)[3] = D_8018E6F8;\n        return 1;\n    }\n    {\n        u16 *qb;   /* D_8017F808 -> $a0 (reloaded) */\n        int qa0;   /* D_8017F80C[0], kept in $a1 for the 2nd-call arg */\n        u16 *qa;   /* D_8017F80C -> $a2 (reloaded) */\n        qb = (u16 *)D_8017F808;\n        qa = (u16 *)D_8017F80C;\n        qa0 = qa[0];\n        if (((qb[0] & 0xFF80) == (qa0 & 0xFF80)) &&\n            ((qb[2] & 0xFF80) == (qa[2] & 0xFF80)))\n            return 0;\n        if (func_80134A74(id, (s16)qa0, (s16)qa[2], D_8018E6E8))\n            goto found;\n        return 0;\n    }\n}\n"}
diff --git a/Makefile b/Makefile
index 900fb0c96a..5f095bd998 100644
--- a/Makefile
+++ b/Makefile
@@ -299,6 +299,10 @@ tools-health:
 	# fresh .run/P35/census/share_census.json for its duplicate-copy fields.
 	$(VENV_PY) tools/share_census.py --selftest
 	$(VENV_PY) tools/share_census.py --check --strict-macros --strict-text --quiet
+	# P36 S103: the hand-asm manifest has no drift. It ran ONLY in CI, so a DECOMPILE-NOW row converted by T4 batch tus10
+	# (cb2fb5e6d, 2026-09-09) turned CI red for a day while every local chain stayed green (R54: a guard that is not
+	# running locally is not a guard). Fix a GONE row with `tools/verbatim_check.py --update` (a one-row diff since S103).
+	$(VENV_PY) tools/verbatim_check.py --strict
 	$(MAKE) --no-print-directory report BINARY=main
 	# AFTER report (which regenerates the digest), so this asserts the freshly-written digest agrees
 	# with the tree — and, on a tree whose digest was committed stale, says so instead of staying green.
diff --git a/config/verbatim_manifest.json b/config/verbatim_manifest.json
index fa6912ba8a..898bf0dbf4 100644
--- a/config/verbatim_manifest.json
+++ b/config/verbatim_manifest.json
@@ -814,20 +814,6 @@
    "path": "src/ov_SC06_032/ov_SC06_032_jr_8017C24C.c",
    "why": "in-function §265 body with a compiler-shaped prologue and no hand-asm marker — a function never decompiled; a Phase-36 residue (Drew: everything short of Sony objects and the original hand asm must be C)",
    "ratified": "2026-09-09 (P36 T1b: listed by the structural detector; SDK rows and the DECOMPILE/UNCERTAIN split are the proposal for Drew)"
-  },
-  {
-   "binary": "ov_SC07_000",
-   "fn": "func_8017EEC0",
-   "addr": "0x8017eec0",
-   "nins": 8,
-   "cls": "GAME-C",
-   "disposition": "DECOMPILE-NOW",
-   "form": "in-function",
-   "unit_entry": "func_8017EEC0",
-   "unit_nins": 8,
-   "path": "src/ov_SC07_000/ov_SC07_000_jr_8017ECB4.c",
-   "why": "in-function §265 body with a compiler-shaped prologue and no hand-asm marker — a function never decompiled; a Phase-36 residue (Drew: everything short of Sony objects and the original hand asm must be C)",
-   "ratified": "2026-09-09 (P36 T1b: listed by the structural detector; SDK rows and the DECOMPILE/UNCERTAIN split are the proposal for Drew)"
   }
  ]
 }
diff --git a/decomp-architect/corpus/record/build/tools-health.mk b/decomp-architect/corpus/record/build/tools-health.mk
index 64eb1f38d7..3ee9e85758 100644
--- a/decomp-architect/corpus/record/build/tools-health.mk
+++ b/decomp-architect/corpus/record/build/tools-health.mk
@@ -45,6 +45,10 @@ tools-health:
 	# fresh .run/P35/census/share_census.json for its duplicate-copy fields.
 	$(VENV_PY) tools/share_census.py --selftest
 	$(VENV_PY) tools/share_census.py --check --strict-macros --strict-text --quiet
+	# P36 S103: the hand-asm manifest has no drift. It ran ONLY in CI, so a DECOMPILE-NOW row converted by T4 batch tus10
+	# (cb2fb5e6d, 2026-09-09) turned CI red for a day while every local chain stayed green (R54: a guard that is not
+	# running locally is not a guard). Fix a GONE row with `tools/verbatim_check.py --update` (a one-row diff since S103).
+	$(VENV_PY) tools/verbatim_check.py --strict
 	$(MAKE) --no-print-directory report BINARY=main
 	# AFTER report (which regenerates the digest), so this asserts the freshly-written digest agrees
 	# with the tree — and, on a tree whose digest was committed stale, says so instead of staying green.
diff --git a/decomp-architect/corpus/tools/P10/delever.py b/decomp-architect/corpus/tools/P10/delever.py
index 7733fca694..0e367bed63 100644
--- a/decomp-architect/corpus/tools/P10/delever.py
+++ b/decomp-architect/corpus/tools/P10/delever.py
@@ -2775,7 +2775,119 @@ def merge_walked_pointers(text, tu, fn, d_):
     return out
 
 
-ALL_FAMILIES = ("R2", "R3", "R4", "R5", "R6", "R7", "R8", "R9", "R10", "R12", "R13", "R14", "R15", "R16", "R17", "R18", "R19", "R20", "R21", "R22")
+_CTRL = re.compile(r"\b(?:if|else|while|for|do|switch|case|default|goto|return|break|continue)\b")
+_LOOPISH = re.compile(r"\b(?:while|for|do|goto)\b|^\s*[A-Za-z_]\w*\s*:(?!:)", re.M)
+
+
+def split_reused_locals(text, tu, fn, d_):
+    """[(description, candidate text)] — R23: a local that is FULLY REDEFINED several times in straight-line code split
+    into one name per value.
+
+    T7 agents c1 (func_80135168, 125 bodies) and c8 (func_80135004, 126 bodies), P36 S103, both closed a register
+    permutation this way: `u16 a, b;` reused by three statement groups became `u16 ax, bx, ay, by, az, bz;`. A pseudo that
+    dies more than once is not a local-alloc candidate (`local-alloc.c:472` takes only a register that dies exactly once
+    in its block), so the reused temps went to GLOBAL allocation — which runs after local-alloc has already handed the
+    pointers their registers. One name per value makes each a single-death local with a high `qty_compare_1` rank
+    (`local-alloc.c:1598-1625`), so they take `$v0/$v1` first and the pointers fall into the target's order. Both closes
+    were JOINT (c1: this move alone 12, a member store alone 20, both 0; c8: this alone 26, a call argument inlined alone
+    16, both 0), so the family also offers every split at once, and the engine composes it with the other families.
+
+    Refused unless `v` is declared without an initialiser in the body's declaration run, its first mention is a full
+    redefinition `v = E;` whose `E` does not read `v`, it has no other write (`+=`, `++`, …) and no `&v`, the definitions
+    lie in straight-line code (no brace or control keyword between the first and the last), and no loop, `goto` or label
+    lies between the first definition and the last use — a renamed segment can then never be reached with the old value."""
+    lines = text.split("\n")
+    lo, hi = d_["line"], d_["end"] - 1
+    if hi <= lo:
+        return []
+    head = "\n".join(lines[:lo]) + "\n"
+    body = "\n".join(lines[lo:hi])
+    tail = "\n" + "\n".join(lines[hi:])
+    mb = sc.mask_text(body)
+    # declarations are read from the WHOLE-BODY mask: `decl_run_end` masks one line at a time, so a multi-line comment
+    # inside the declaration run ends it early (func_80135168's `[T51]` note returned a run of 0 lines — found by the
+    # known-true check against agent c1's own start text, S103)
+    DL = re.compile(r"^(\s*(?:unsigned\s+|signed\s+|const\s+)*[A-Za-z_]\w*\s+)([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)\s*;\s*$")
+    decls = {}
+    for j, ml in enumerate(mb.split("\n")):
+        m = DL.match(ml)
+        if m and not m.group(1).strip() in ("return", "goto", "extern", "static", "typedef", "else", "do"):
+            for n in re.split(r"\s*,\s*", m.group(2).strip()):
+                decls[n] = lo + j
+    idents = set(re.findall(r"[A-Za-z_]\w*", text))
+    decl_off = {}                                           # line index -> char offset of that line inside `body`
+    off = 0
+    for i in range(lo, hi):
+        decl_off[i] = off
+        off += len(lines[i]) + 1
+
+    def plan(v):
+        dl_i = decls[v]
+        dl_lo, dl_hi = decl_off[dl_i], decl_off[dl_i] + len(lines[dl_i])
+        occ = [m.start() for m in re.finditer(r"(?<![\w.>])%s\b" % re.escape(v), mb) if not dl_lo <= m.start() < dl_hi]
+        if not occ:
+            return None
+        defs = []
+        for p in occ:
+            after, before = mb[p + len(v):], mb[:p].rstrip()
+            if re.match(r"\s*(?:\+\+|--|[-+*/%&|^]=|<<=|>>=)", after) or before.endswith(("++", "--", "&")):
+                return None
+            if re.match(r"\s*=(?!=)", after):
+                semi = mb.find(";", p)
+                if semi < 0 or re.search(r"(?<![\w.>])%s\b" % re.escape(v), mb[p + len(v):semi]):
+                    return None
+                if before and not before.endswith((";", "{", "}")) and not re.search(r"\)\s*$", before):
+                    return None                              # an assignment inside an expression, not a statement
+                defs.append(p)
+        if len(defs) < 2 or occ[0] != defs[0]:
+            return None
+        if re.search(r"[{}]", mb[defs[0]:defs[-1]]) or _CTRL.search(mb[defs[0]:defs[-1]]):
+            return None
+        if _LOOPISH.search(mb[defs[0]:occ[-1]]):
+            return None
+        names = []
+        for k in range(2, len(defs) + 1):
+            n = f"{v}{k}"
+            if n in idents or n in names:
+                n = f"{v}_{k}"
+            if n in idents or n in names:
+                return None
+            names.append(n)
+        return dl_i, defs, occ, names
+
+    def apply(vs, src_lines, src_body):
+        edits = []                                          # (start, end, replacement) inside the body
+        decl_edits = {}
+        for v in vs:
+            dl_i, defs, occ, names = plans[v]
+            bounds = defs[1:] + [len(src_body)]
+            for k, (a, b) in enumerate(zip(defs[1:], bounds[1:])):
+                for p in occ:
+                    if a <= p < b:
+                        edits.append((p, p + len(v), names[k]))
+            decl_edits.setdefault(dl_i, []).append((v, names))
+        new = src_body
+        for a, b, r in sorted(edits, reverse=True):
+            new = new[:a] + r + new[b:]
+        nl = new.split("\n")
+        for dl_i, items in decl_edits.items():
+            j = dl_i - lo
+            for v, names in items:
+                nl[j] = re.sub(r"(?<![\w.>])%s\b" % re.escape(v), ", ".join([v] + names), nl[j], count=1)
+        return head + "\n".join(nl) + tail
+
+    plans = {}
+    for v in decls:
+        p = plan(v)
+        if p:
+            plans[v] = p
+    out = [(f"split {v} into {len(plans[v][1])}", apply([v], lines, body)) for v in plans]
+    if len(plans) > 1:
+        out.append((f"split ALL {'+'.join(plans)}", apply(list(plans), lines, body)))
+    return out
+
+
+ALL_FAMILIES = ("R2", "R3", "R4", "R5", "R6", "R7", "R8", "R9", "R10", "R12", "R13", "R14", "R15", "R16", "R17", "R18", "R19", "R20", "R21", "R22", "R23")
 RUNG_R_FAMILIES = ("R2", "R3", "R4", "R5", "R6", "R7")     # the free sweep's set (R8/R9 are the search engine's until measured)
 
 
@@ -2904,6 +3016,9 @@ def recipe_candidates(text, tu, fn, names, limit=24, rng=None, cap=40, blocks=Tr
     if "R22" in fam:
         for desc, cand in merge_walked_pointers(text, tu, fn, d_):
             out.append(("R22", desc, cand))
+    if "R23" in fam:
+        for desc, cand in split_reused_locals(text, tu, fn, d_):
+            out.append(("R23", desc, cand))
     if blocks and "R7" in fam:                            # last: one candidate per statement, so the targeted recipes go first
         for desc, cand in block_wraps(text, tu, fn, d_):
             out.append(("R7", desc, cand))
@@ -3887,6 +4002,33 @@ def selftest():
                                  next(r for r in sc.scan_text(bad, "src/fx/w.c", shared_defs=None) if r["form"] == "def")):
             fail(f"R22 must refuse {why}")
 
+    # R23, one name per value (T7 agents c1/c8, P36 S103; known-true: on each agent's own start text R23's joint split
+    # scores exactly the number the agent measured for that move alone — 12 for func_80135168, 26 for func_80135004).
+    RFIX = ("void func_80100000(s16 *p1, s16 *p2, s16 *q) {\n"
+            "    /* a note that\n"
+            "       spans lines */\n"
+            "    u16 a, b;\n"
+            "\n"
+            "    a = p2[0]; q[0] = a; b = p1[0]; q[1] = a - b;\n"
+            "    a = p2[1]; q[2] = a; b = p1[1]; q[3] = a - b;\n"
+            "}")
+    dR = next(r for r in sc.scan_text(RFIX, "src/fx/r.c", shared_defs=None) if r["form"] == "def")
+    r23 = dict(split_reused_locals(RFIX, "src/fx/r.c", "func_80100000", dR))
+    if sorted(r23) != ["split ALL a+b", "split a into 2", "split b into 2"]:
+        fail(f"R23 must offer each reused local and the joint split (past a multi-line comment), got {sorted(r23)}")
+    else:
+        j = r23["split ALL a+b"]
+        if "u16 a, a2, b, b2;" not in j or "a2 = p2[1]; q[2] = a2; b2 = p1[1]; q[3] = a2 - b2;" not in j \
+                or "a = p2[0]; q[0] = a; b = p1[0]; q[1] = a - b;" not in j:
+            fail(f"R23's joint split must rename every later segment and declare the names: {j!r}")
+    # controls: a compound write, and a loop between the definitions, each refuse the split
+    for bad, why in ((RFIX.replace("q[3] = a - b;", "q[3] = a - b; a += 1;"), "a compound write"),
+                     (RFIX.replace("    a = p2[1];", "    while (*q) q++;\n    a = p2[1];"), "a loop between the definitions")):
+        got = dict(split_reused_locals(bad, "src/fx/r.c", "func_80100000",
+                                       next(r for r in sc.scan_text(bad, "src/fx/r.c", shared_defs=None) if r["form"] == "def")))
+        if "split a into 2" in got:
+            fail(f"R23 must refuse {why}: {sorted(got)}")
+
     # the oracle's crash classification on its real message forms (R103)
     if not oracle.SIGNAL_LINE.search("bash: line 1: 3845091 Done   mipsel-linux-gnu-cpp ...\n     3845092 Aborted                 (core dumped) | tools/bin/gcc-2.7.2-psx/cc1 -quiet\n"):
         fail("SIGNAL_LINE must match bash's job-status block")
diff --git a/decomp-architect/corpus/tools/P10/delever_search.py b/decomp-architect/corpus/tools/P10/delever_search.py
index e2bc666ac3..a29f0d92cd 100644
--- a/decomp-architect/corpus/tools/P10/delever_search.py
+++ b/decomp-architect/corpus/tools/P10/delever_search.py
@@ -88,17 +88,17 @@ FAMILIES = {
     # R15 (the sink) is the arm-scoped form of the same tie: a value set in every arm of an if/else chain is a CROSS-BLOCK
     # pseudo local-alloc never gives a quantity, so the arm holds two quantities and takes block_alloc's unrolled case 2;
     # sinking makes it three, and case 3 falls through into case 2 and undoes its own exchange (T7 agent a1, func_80156044).
-    "REG-caller": ("R19", "R21", "R6", "R20", "R16", "R8", "R15", "R17", "R5", "R18", "R10", "R12", "R14", "R13", "R3", "R7", "R9", "R2", "R4", "R22"),
+    "REG-caller": ("R19", "R23", "R21", "R6", "R20", "R16", "R8", "R15", "R17", "R5", "R18", "R10", "R12", "R14", "R13", "R3", "R7", "R9", "R2", "R4", "R22"),
     # the s-bank order is global.c's allocno_compare (ref weight x live length), declaration order only on an exact tie
-    "REG-callee": ("R19", "R21", "R20", "R2", "R4", "R3", "R6", "R16", "R8", "R15", "R18", "R12", "R7", "R9", "R17", "R10", "R14", "R13", "R5", "R22"),
-    "REG-mixed": ("R19", "R21", "R6", "R20", "R16", "R2", "R15", "R17", "R18", "R5", "R10", "R4", "R3", "R8", "R12", "R13", "R14", "R7", "R9", "R22"),
+    "REG-callee": ("R19", "R23", "R21", "R20", "R2", "R4", "R3", "R6", "R16", "R8", "R15", "R18", "R12", "R7", "R9", "R17", "R10", "R14", "R13", "R5", "R22"),
+    "REG-mixed": ("R19", "R23", "R21", "R6", "R20", "R16", "R2", "R15", "R17", "R18", "R5", "R10", "R4", "R3", "R8", "R12", "R13", "R14", "R7", "R9", "R22"),
     # a copy dies to cse's canon_reg or the local-alloc tie unless its destination changes MODE (the width); an address
     # pseudo lives when a pointer local is used twice; a value named once is computed once; a short PARAMETER is extended in place
-    "COUNT": ("R19", "R22", "R21", "R20", "R12", "R16", "R14", "R15", "R6", "R8", "R3", "R18", "R7", "R17", "R5", "R13", "R9", "R10", "R2", "R4"),
+    "COUNT": ("R19", "R22", "R21", "R20", "R12", "R16", "R14", "R15", "R6", "R8", "R3", "R18", "R7", "R17", "R5", "R13", "R9", "R10", "R2", "R4", "R23"),
     # statement order IS the schedule among equal-priority insns (rank_for_schedule's LUID tie-break); do-while is a barrier
     # R17 is the DIRECTED form of the run-split R9 reaches only by luck: agent a2 measured 2,271 compiles for R9 to find it
     # in func_80168828 and R16+R17 reproduce the same close in ten.
-    "ORDER": ("R19", "R17", "R18", "R20", "R21", "R9", "R7", "R13", "R3", "R16", "R6", "R8", "R5", "R12", "R14", "R10", "R15", "R2", "R4", "R22"),
+    "ORDER": ("R19", "R17", "R18", "R20", "R21", "R9", "R7", "R13", "R3", "R16", "R6", "R8", "R5", "R12", "R14", "R10", "R15", "R2", "R4", "R22", "R23"),
     "MIXED": dl.ALL_FAMILIES,
     "OTHER": dl.ALL_FAMILIES,
 }
diff --git a/decomp-architect/corpus/tools/P10/verbatim_check.py b/decomp-architect/corpus/tools/P10/verbatim_check.py
index 46bfb2f33e..66e9fbb407 100644
--- a/decomp-architect/corpus/tools/P10/verbatim_check.py
+++ b/decomp-architect/corpus/tools/P10/verbatim_check.py
@@ -243,8 +243,12 @@ def main():
             keep.append(dict(binary=b, fn=fn, addr=None, nins=None, cls='UNCLASSIFIED',
                              disposition='UNKNOWN', form=form_of.get((b, fn), 'file-scope'), unit_entry=fn, unit_nins=None,
                              path=found_k[(b, fn)], why='added by --update; NEEDS CLASSIFICATION'))
-        man['rows'] = sorted(keep, key=lambda r: (r['binary'], r['fn']))
-        json.dump(man, open(MANIFEST, 'w'), indent=1)
+        # the manifest's row ORDER and its non-ASCII text (§, —, ·) are part of the file: the first --update of P36 S103
+        # re-sorted every row and escaped every character, a 588-line diff for one removed row. Keep the order, append
+        # the new rows, write UTF-8 as it was written (R57 — the instrument's write path is part of the instrument).
+        man['rows'] = keep
+        with open(MANIFEST, 'w') as fh:
+            fh.write(json.dumps(man, indent=1, ensure_ascii=False) + '\n')
         print(f'\nmanifest updated: {len(rows)} -> {len(man["rows"])} rows '
               f'({len(new)} added as UNCLASSIFIED — classify them)')
     if a.strict and (new or gone or moved):
diff --git a/docs/SETUP.md b/docs/SETUP.md
index 4cea6890f4..d4dceead20 100644
--- a/docs/SETUP.md
+++ b/docs/SETUP.md
@@ -1710,6 +1710,7 @@ carries its mechanism, its `file:line` citations into `tools/reference/gcc-2.7.2
 | R20 | `narrow_chains` | every local in one def-use chain narrowed TOGETHER, and each pair of chains together | agent b3, `func_8016CBC0` |
 | R21 | `second_consumer` | `v = E; slot = v;` → `v = slot = E;` (chain) or `slot = E; v = E;` (hoist), each site and ALL sites | agents b2/b6 |
 | R22 | `merge_walked_pointers` | a second pointer `q = p + K` stepped in lockstep with `p` deleted; `q[n]` → `p[n+K]`, `*q` → `p[K]` (S103; leads the COUNT class after R19) | agent c2, `func_8013D8FC` — known-true: its start text's R22 candidate is the agent's closing body, score 0 |
+| R23 | `split_reused_locals` | a local fully redefined several times in straight-line code split into one name per value (`u16 a, b;` → `u16 a, a2, a3, b, b2, b3;`), each and ALL (S103; leads the REG classes after R19) | agents c1 `func_80135168` / c8 `func_80135004` — known-true: its joint split scores exactly what each agent measured for the move alone (12, 26) |
 
 **Three of these are JOINT edits and that is the point.** R20's single-chain candidates score 43 and 51 where the joint
 scores 0; R21's single sites are worse than its joint form; b7's four-way retype has every intermediate worse than the
@@ -1765,3 +1766,22 @@ side, and every `@class:`/`@stuck:`/`@crack:` note in the TU — and `best_body.
 engine reached. Both came from agents: one closed on its first try after reading a sibling's header, and one lost hours
 because the pack had reduced its own function's eight-point English header to two tagged lines. **A `@stuck:` note is a
 CLAIM, not a fact — two were refuted on bytes on 2026-09-10.**
+
+### §P36 S103 — 2026-09-10: two generators, the method file, and `verbatim_check` in the local chain
+
+- **Generators R22 and R23** (rows in the §P36 S102 generator table above): R22 `merge_walked_pointers` (agent c2) and
+  R23 `split_reused_locals` (agents c1/c8, one name per value — a pseudo that dies more than once is not a local-alloc
+  candidate, `local-alloc.c:472`). R23 reads declarations from the WHOLE-BODY mask because `decl_run_end` masks one line
+  at a time and ends the declaration run at a multi-line comment (it returned a run of 0 lines on `func_80135168`; R3's
+  init-split shares that limitation). Known-true checks: R22's candidate from c2's start text IS its closing body (score 0);
+  R23's joint split scores exactly what c1 and c8 measured for that move alone (12, 26).
+- **`.run/P36/agents/METHOD_S103.md`** — the method every agent brief cites (after `PROMPT.md`, taking precedence): count
+  first, the whole-function dump, the emitters of a missing instruction with the S103 additions (the walked-pointer merge,
+  the `u16` width move for a surviving copy, the implicit handler argument), the allocation arithmetic, joint edits, the
+  refusals. Grown at every landing.
+- **The agent lane runs at most FIVE agents at once** (Drew, 2026-09-10). Fable 5.1 may be out of credits: an agent that
+  dies with HTTP 429 on its first step is relaunched on Opus (R40 — the harness, not the function).
+- **`tools/verbatim_check.py --strict` is now in `make tools-health`** (it ran only in CI: a DECOMPILE-NOW row converted by
+  T4 batch tus10 kept CI red while every local chain was green). `--update` now keeps the manifest's row order and writes
+  UTF-8 (it used to re-sort every row and escape every `§`/`—`, a 588-line diff for one removed row); its output was
+  proven byte-identical to a hand-made one-row removal.
diff --git a/docs/lever-progress.tsv b/docs/lever-progress.tsv
index 7c2bc490ef..574d18439d 100644
--- a/docs/lever-progress.tsv
+++ b/docs/lever-progress.tsv
@@ -30,3 +30,4 @@ date	milestone	head	sites_AB	pins	asm	bodies_AB	distinct_AB	marked	unmarked	gte_
 2026-09-10	S102 T7 b8 — func_80135888: a guarded do-while defeating cross-jump, a duplicated block replaced by goto to shed one loop-weighted reference, and a two-arm temp inlined (134 bodies, the largest class)	0d92d1029	24119	13879	10240	6317	1257	24119	0	462	314	1590	50	7680	445	76
 2026-09-10	S102 wave b close — 8 agent closes banked (b1/b2/b3/b5/b5s/b6/b7/b8), b4/b9 read without closing; R19/R20/R21 added; fleet 218/218	f96af3e48	24119	13879	10240	6317	1257	24119	0	462	314	1590	50	7680	445	76
 2026-09-10	S103 c2: func_8013D8FC closed by agent c2 (the walked-pointer merge, now generator R22), 131 bodies	82da34b39	23988	13748	10240	6186	1256	23988	0	462	314	1590	50	7680	445	76
+2026-09-10	S103 wave c: c4/c6/c1/c7/c3/c5/c8 closed (two new generators R22/R23) + func_8017EEC0's parameter; 8 classes, ~1,000 bodies	205331765	20206	11271	8935	5277	1249	20206	0	462	314	1590	50	7680	445	76
diff --git a/docs/levers.md b/docs/levers.md
index 5872fff23e..8758dc857d 100644
--- a/docs/levers.md
+++ b/docs/levers.md
@@ -76,6 +76,7 @@ counted, not marked). E, F and G belong to the canonical type layer and are the
 | 2026-09-10 | S102 T7 b8 — func_80135888: a guarded do-while defeating cross-jump, a duplicated block replaced by goto to shed one loop-weighted reference, and a two-arm temp inlined (134 bodies, the largest class) | 13879 | 10240 | **24119** | 6317 | 1257 | 462 | 314 | 1590 | 50 | 7680 | 445 | 76 | `0d92d1029` |
 | 2026-09-10 | S102 wave b close — 8 agent closes banked (b1/b2/b3/b5/b5s/b6/b7/b8), b4/b9 read without closing; R19/R20/R21 added; fleet 218/218 | 13879 | 10240 | **24119** | 6317 | 1257 | 462 | 314 | 1590 | 50 | 7680 | 445 | 76 | `f96af3e48` |
 | 2026-09-10 | S103 c2: func_8013D8FC closed by agent c2 (the walked-pointer merge, now generator R22), 131 bodies | 13748 | 10240 | **23988** | 6186 | 1256 | 462 | 314 | 1590 | 50 | 7680 | 445 | 76 | `82da34b39` |
+| 2026-09-10 | S103 wave c: c4/c6/c1/c7/c3/c5/c8 closed (two new generators R22/R23) + func_8017EEC0's parameter; 8 classes, ~1,000 bodies | 11271 | 8935 | **20206** | 5277 | 1249 | 462 | 314 | 1590 | 50 | 7680 | 445 | 76 | `205331765` |
 
 ### The campaign — every batch, from the ledger (derived on every render)
 
@@ -177,7 +178,21 @@ counted, not marked). E, F and G belong to the canonical type layer and are the
 | `b8p` | 2026-09-10 | E | 0 | 0 | 0 | 665 | 133 |
 | `c2` | 2026-09-10 | E | 0 | 0 | 0 | 1 | 1 |
 | `c2p` | 2026-09-10 | E | 0 | 0 | 0 | 130 | 130 |
-| **total** | | | **17,119** | **20,778** | **283** | **10,265** | **6,535** |
+| `c4` | 2026-09-10 | E | 0 | 0 | 0 | 4 | 1 |
+| `c4p` | 2026-09-10 | E | 0 | 0 | 0 | 532 | 133 |
+| `c6` | 2026-09-10 | E | 0 | 0 | 0 | 4 | 1 |
+| `c6p` | 2026-09-10 | E | 0 | 0 | 0 | 516 | 129 |
+| `c1` | 2026-09-10 | E | 0 | 0 | 0 | 5 | 1 |
+| `c1p` | 2026-09-10 | E | 0 | 0 | 0 | 625 | 125 |
+| `c7` | 2026-09-10 | E | 0 | 0 | 0 | 5 | 1 |
+| `c7p` | 2026-09-10 | E | 0 | 0 | 0 | 665 | 133 |
+| `c3` | 2026-09-10 | E | 0 | 0 | 0 | 6 | 1 |
+| `c3p` | 2026-09-10 | E | 0 | 0 | 0 | 786 | 131 |
+| `c5` | 2026-09-10 | E | 0 | 0 | 0 | 1 | 1 |
+| `c5p` | 2026-09-10 | E | 0 | 0 | 0 | 125 | 125 |
+| `c8` | 2026-09-10 | E | 0 | 0 | 0 | 4 | 1 |
+| `c8p` | 2026-09-10 | E | 0 | 0 | 0 | 504 | 126 |
+| **total** | | | **17,119** | **20,778** | **283** | **14,047** | **7,444** |
 
 *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/docs/tool-index.md b/docs/tool-index.md
index c3cee1353b..8b483f822b 100644
--- a/docs/tool-index.md
+++ b/docs/tool-index.md
@@ -332,7 +332,7 @@ then what proved it. The same data generates the day-one kit's manifest and its
 | find every call site whose in-scope declaration is narrower than the callee real definition | `argcheck.py` | The static filter for the missing-argument class: six T7 agents independently reached score 0 by restoring an argument the decompiled source had dropped (m2c drops them at unprototyped and indirect call sites), and no candidate generator can reach it because every family rewrites statements and declarations while this changes a call ARITY. Reads the real arity from the DEFINITION wherever it lives (a .c under src/ or a shared body header) and reports each narrower declaration with the scope that says which fix is available: the cast route is body-only at either scope, widening the declaration itself needs block scope. Known blind spot, stated in the docstring: it cannot see a definition that is uniformly wrong. | decl_repair.py, delever.py, readability_progress.py | repo paths; the census walk | LIVE |
 | flag address-named references whose address now has a curated name | `lint_symbol_refs.py` | Flags address-named references in committed sources whose address now has a curated name | .github/workflows/no-rom.yml, Makefile | repo symbol/src paths | LIVE |
 | give each conflicting camp of a same-named type its own name | `uniquify_type.py` | Gives each conflicting camp of a same-named type its own name so every camp becomes liftable | — | repo src layout | REFERENCED |
-| guard that every inline-assembly body still reproduces its target bytes | `verbatim_check.py` | Regression guard that every inline-assembly body still reproduces its target bytes | .github/workflows/no-rom.yml, lever_census.py, progress.py, verbatim_target_s.py (+1) | repo src layout | LIVE |
+| guard that every inline-assembly body still reproduces its target bytes | `verbatim_check.py` | Regression guard that every inline-assembly body still reproduces its target bytes | .github/workflows/no-rom.yml, Makefile, lever_census.py, progress.py (+2) | repo src layout | LIVE |
 | judge one translation-unit edit by the bytes of its object in under a second | `delever_oracle.py` | The Phase-36 fast byte oracle: every object's exact build command captured once via make -n -W (the Makefile's own recipe, pad stage and -O0 overrides included), a candidate compiled in place with -o/-MF redirected to scratch and compared with the fleet run's object; --calibrate proves 100 % equality untouched, twin == primary and a positive control before any verdict is trusted | delever.py, delever_cycle.sh, delever_permute.py, delever_search.py (+1) | the Makefile's object rules, the twin rule | LIVE |
 | keep the lever count as a series a chart and a story can be drawn from | `lever_progress.py` | The Phase-36 lever series: a milestone row appended per census snapshot (its totals by class with the tree's HEAD, since a census is a moment that cannot be recovered later) plus the campaign table derived from the de-lever ledger on every render — per batch the rungs used, the bodies first judged, the sites removed and rewritten, and, scored as a transition against what that body's previous row left, the sites a later rung closed and the bodies it made lever-free; renders both into docs/levers.md's generated block and --check refuses a series that is not this tree's | readability_progress.py | the census json, the delever ledger | LIVE |
 | measure duplicate function bodies across the fleet and assert one source per unique function | `share_census.py` | The census of byte-identical function classes across every binary with their source forms and verdicts, plus the S1 invariant check with its exception ledger and a fixture self-test | Makefile, audit_binaries.py, dedup_integrate.py, delever.py (+11) | repo paths, the registry and signature schemas | LIVE |
diff --git a/phase-ends/CURRENT_PHASE.md b/phase-ends/CURRENT_PHASE.md
index 39b217ed2f..3b58feb9d8 100644
--- a/phase-ends/CURRENT_PHASE.md
+++ b/phase-ends/CURRENT_PHASE.md
@@ -96,6 +96,9 @@
   residue counted as a lever). The 20 per-overlay trampoline families (133 private copies each, bytes varying with the wrapped callee)
   are the names phase's parameterized-form inheritance.
 
+- **S103 (2026-09-10), Drew: *"max concurrent agents is 5, leave the ones you have running, but maintain max of 5
+  concurrent agents from now on."*** → the T7 agent lane runs at most FIVE agents at once (six were running when he said
+  it; they finish, and no new one launches until fewer than five are live).
 - **S98 (2026-09-09), Drew, mid-T3:** *"dont start ultra code wave for reshaping without my direct approval."* → **T7's reshaping waves (Ultracode) start ONLY on Drew's direct approval in the session that would run them** — the R27 toggle is necessary, not sufficient; the T6 recipe/permuter rungs and the mechanical campaign are not waves and proceed under P3.
 
 ## Rules at gate 1 (P10)
@@ -1356,6 +1359,44 @@ accumulate here as the phase produces them.**
   --selftest: OK`; SETUP generator table row. The mechanical search had ~3,500 compiles on this body and no move that
   merges two walked pointers — it could never close a whole extra loop variable.
 
+- **S103 — wave c lands: SEVEN more agent closes + one coordinator bank, 23,988 → 20,206 sites (−3,782).** Every body
+  `--try` score 0 before the next agent launched, then `apply-body … IDENTICAL … KEPT` and `--propagate … N of N
+  sibling(s) banked, 0 refused`: **c4 `func_80133AB0`** (24 → 0, 137/137; 133/133) three WIDTH moves — a flag copy, the
+  X/Y copies split out of `u32 X, Y, cell, Xc, Yc;`, a counter — to `u16`: no PROMOTE_MODE on MIPS, a same-mode SI copy
+  is folded by cse's `(set REG0 REG1)` case (`cse.c:7440-7474`, gate `:7455`), a HImode copy is a SUBREG move and
+  survives, a `u16 cnt--` takes `copy_to_reg` (`expr.c:8645`); **c6 `func_80130D48`** (18 → 0, 266/266; 129/129) a
+  shared `goto do_call` tail given one call per case — the parameter's refs 4 → 11 lift its `allocno_compare` priority
+  384.6 → 1586.5 past the rival's 1212.1 (`global.c:594-607`); cross-jump re-merges the calls AFTER allocation
+  (`toplev.c:3142`, `jump.c:2371`), so the bytes keep one call; **c1 `func_80135168`** (25 → 0, 62/62; 125/125) reused
+  temps split one pair per group (a pseudo dying 3× is not a local-alloc candidate, `local-alloc.c:472`) JOINT with the
+  global store written as an `H16` member store, whose MEM_IN_STRUCT_P keeps sched1's anti-dependence
+  (`sched.c:858-863`, `expr.c:4888`) the `"memory"` barrier was faking; **c7 `func_80134A74`** (30 → 0, 107/107;
+  133/133) c4's width moves (relayed mid-run) + the struct fields copied to locals before the loop + `lst--` written in
+  both arms of an if/else, which adds loop-weighted refs (`flow.c:2067`) and flips `allocno_compare` 3684 → 8461 vs
+  7674; **c3 `func_80148AFC`** (23 → 0, 71/71; 131/131) the angle passed as the dispatch handler's implicit SECOND
+  argument (the TU's `ActorFn` was one argument too narrow) JOINT with `tmp` reused as the LATER operand so its last
+  mention wins `make_regs_eqv` (`cse.c:846-862`, the swap at `:7454`); **c5 `func_8015D738`** (17 → 0, 201/201;
+  125/125) jump threading (`jump.c:4161`; `-fno-thread-jumps` reproduces the target in one compile): the pointer
+  re-read before the second null test JOINT with a `do { … } while (0);` around its first read — **the agent flagged the
+  do-while as a possible lever; banked on precedent (R7 emits it, S102's a4 and b8 banked with it, the census does not
+  count it, 1,347 in `src/`) and the class RAISED WITH DREW**; **c8 `func_80135004`** (26 → 0, 89/89; 126/126) c1's
+  temp split (relayed) JOINT with `D_801EDA30` passed straight to the call — a load stays a separate insn when a store
+  lies between it and its use (`combine.c:914-917`, `:10134`); **coordinator `func_8017EEC0`** (ov_SC07_000): the
+  uninitialised `s32 a0v;` T4 batch tus10 left when it took the `$4` pin off is the function's PARAMETER —
+  `void func_8017EEC0(s32 *a0)` scores 0 (8/8), IDENTICAL, KEPT (its callers still declare it `(void)`: the
+  too-few-arguments group). R22 after the first four: `check-all: 218 passed, 0 failed of 218`; after all eight:
+  `check-all: 218 passed, 0 failed of 218`; `lever_census --check: 20,206 pin/asm sites, 20,206 marked !FAKE, 0 UNMARKED — OK`.
+  **CI was red since 2026-09-09 (Drew's report, run 34525907006):** `verbatim_check --strict` → `1 manifest row(s) no
+  longer verbatim … ov_SC07_000 func_8017EEC0` — the DECOMPILE-NOW row went stale when T4 batch `tus10` (`cb2fb5e6d`)
+  converted it, and the check ran ONLY in CI. Fixed: the row removed (a one-row, 14-line diff), `--update` repaired to keep
+  row order and write UTF-8 (its first run re-sorted and escaped the file: 588 lines for one row) and proven
+  byte-identical to the hand removal, **`verbatim_check --strict` wired into `make tools-health`** — `verbatim strict
+  rc=0`. **Harvest: generator R23 `split_reused_locals`** (c1/c8's move; one name per value), selftest fixture past a
+  multi-line comment + two refusal controls (`delever --selftest: OK`); known-true: its joint split scores **12** on c1's
+  start text and **26** on c8's — exactly the numbers each agent measured for that move alone; R6 does not reach c8's
+  second move (a temp in a multi-statement line), so the full close stays an agent result. **Drew set the lane to at
+  most five concurrent agents.** Relayed mid-run twice (c4 → c7, c1 → c8), and both relays were used in the close.
+
 ## 🛑 SESSION CHECKPOINT — S102 (2026-09-10): T0–T6 ☑, **T7 RUNNING AND PRODUCTIVE**. 30,358 → **24,119 sites** (−6,239) in 6,317 bodies; 22 agents across two waves (14 closed, 8 read); generators **R15–R21** added, each with a known-true check; **16,759 lying call declarations repaired free** across 3,439 units; R22 `check-all: 218 passed, 0 failed of 218` at every step | `lever_census --check` OK (24,119 marked, 0 UNMARKED) · `lever_progress --check` OK (30 milestones) · tree CLEAN at `8a22254bf`
 
 ### 0. How to use this block
diff --git a/src/ov_MAIN_012/ov_MAIN_012_jr_80131340.c b/src/ov_MAIN_012/ov_MAIN_012_jr_80131340.c
index 6b77853215..70916d5800 100644
--- a/src/ov_MAIN_012/ov_MAIN_012_jr_80131340.c
+++ b/src/ov_MAIN_012/ov_MAIN_012_jr_80131340.c
@@ -1529,15 +1529,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017E914);
     u16 *pB = (*(u16 * *)&D_8017E910);
     u16 *pC = (*(u16 * *)&D_8017E91C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -1548,15 +1548,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -1569,10 +1569,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2000,57 +2000,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_80184130;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_80184130 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_80184130 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
diff --git a/src/ov_MAIN_012/ov_MAIN_012_jr_801458E0.c b/src/ov_MAIN_012/ov_MAIN_012_jr_801458E0.c
index 375ca2783e..ccc5794d73 100644
--- a/src/ov_MAIN_012/ov_MAIN_012_jr_801458E0.c
+++ b/src/ov_MAIN_012/ov_MAIN_012_jr_801458E0.c
@@ -1896,38 +1896,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8017FE78[];
+    extern s32 (*D_8017FE78[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8017FE78[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8017FE78[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC01_000/ov_SC01_000_after.c b/src/ov_SC01_000/ov_SC01_000_after.c
index 0696c17b34..c53ffafe35 100644
--- a/src/ov_SC01_000/ov_SC01_000_after.c
+++ b/src/ov_SC01_000/ov_SC01_000_after.c
@@ -637,38 +637,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80180700[];
+    extern s32 (*D_80180700[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80180700[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80180700[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c b/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c
index b8bfbffd95..a7d702cd02 100644
--- a/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c
+++ b/src/ov_SC01_000/ov_SC01_000_jr_8012ACE0.c
@@ -1130,156 +1130,136 @@ extern s16 D_8017F0A0[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F018; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017F078;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017F018 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F080; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017F078;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017F080 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F0A0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017F0A0 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017EFE8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017EFE8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2305,15 +2285,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017F19C);
     u16 *pB = (*(u16 * *)&D_8017F198);
     u16 *pC = (*(u16 * *)&D_8017F1A4);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2324,15 +2304,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2345,10 +2325,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2776,57 +2756,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A4458;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A4458 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A4458 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2937,26 +2912,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017F1A0;
     extern u16 D_801A4458;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017F19C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017F198 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017F1A4 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017F19C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017F198; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F1A4); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017F198; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F1A4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A4448;
+    a1v = pac[0]; a2v = pac[2];
     D_801A4458 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A4448)) {
     found:
         pb4 = (*(u16 * *)&D_8017F1A0);
         ((u16 *)p2)[0] = pb4[0];
@@ -3002,23 +2976,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017F198;
     extern u8 D_8017F19C;
     extern u8 D_8017F1A4;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017F19C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017F198); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F1A4); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017F198); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F1A4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A4448;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801A4458 = 0;
+    ((H16 *)&D_801A4458)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017F1A0);
         p2[0] = pb4[0];
diff --git a/src/ov_SC01_000/ov_SC01_000_jr_8015C32C.c b/src/ov_SC01_000/ov_SC01_000_jr_8015C32C.c
index 5b4543f103..84fab05410 100644
--- a/src/ov_SC01_000/ov_SC01_000_jr_8015C32C.c
+++ b/src/ov_SC01_000/ov_SC01_000_jr_8015C32C.c
@@ -1951,19 +1951,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801812A4[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801812A4[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC01_001/ov_SC01_001_after.c b/src/ov_SC01_001/ov_SC01_001_after.c
index 7723bbe45e..1be65f2d8a 100644
--- a/src/ov_SC01_001/ov_SC01_001_after.c
+++ b/src/ov_SC01_001/ov_SC01_001_after.c
@@ -637,38 +637,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80185350[];
+    extern s32 (*D_80185350[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80185350[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80185350[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.c b/src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.c
index a54a683f01..8a222d9b92 100644
--- a/src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.c
+++ b/src/ov_SC01_001/ov_SC01_001_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_80183CF0[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183C68; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80183CC8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80183C68 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183CD0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80183CC8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80183CD0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183CF0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80183CF0 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80183C38;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80183C38;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2305,15 +2285,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80183DEC);
     u16 *pB = (*(u16 * *)&D_80183DE8);
     u16 *pC = (*(u16 * *)&D_80183DF4);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2324,15 +2304,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2345,10 +2325,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2776,57 +2756,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801EC6E8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801EC6E8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801EC6E8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2937,26 +2912,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80183DF0;
     extern u16 D_801EC6E8;
 
-    register s16 *pb0 __asm__("$9");   /* D_80183DEC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80183DE8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80183DF4 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80183DEC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80183DE8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183DF4); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80183DE8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183DF4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801EC6D8;
+    a1v = pac[0]; a2v = pac[2];
     D_801EC6E8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801EC6D8)) {
     found:
         pb4 = (*(u16 * *)&D_80183DF0);
         ((u16 *)p2)[0] = pb4[0];
@@ -3002,23 +2976,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80183DE8;
     extern u8 D_80183DEC;
     extern u8 D_80183DF4;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80183DEC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80183DE8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80183DF4); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80183DE8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80183DF4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801EC6D8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801EC6E8 = 0;
+    ((H16 *)&D_801EC6E8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80183DF0);
         p2[0] = pb4[0];
diff --git a/src/ov_SC01_001/ov_SC01_001_jr_8015C32C.c b/src/ov_SC01_001/ov_SC01_001_jr_8015C32C.c
index ac96e12ec1..1f6a706d1c 100644
--- a/src/ov_SC01_001/ov_SC01_001_jr_8015C32C.c
+++ b/src/ov_SC01_001/ov_SC01_001_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80185EF4[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80185EF4[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC01_004/ov_SC01_004_after.c b/src/ov_SC01_004/ov_SC01_004_after.c
index c68ab5d7d1..f900368a35 100644
--- a/src/ov_SC01_004/ov_SC01_004_after.c
+++ b/src/ov_SC01_004/ov_SC01_004_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80180D14[];
+    extern s32 (*D_80180D14[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80180D14[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80180D14[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.c b/src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.c
index 0b45dca72d..cdb6316e1d 100644
--- a/src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.c
+++ b/src/ov_SC01_004/ov_SC01_004_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_8017F6B4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F62C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017F68C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017F62C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F694; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017F68C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017F694 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F6B4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017F6B4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017F5FC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017F5FC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017F7B0);
     u16 *pB = (*(u16 * *)&D_8017F7AC);
     u16 *pC = (*(u16 * *)&D_8017F7B8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8018EE50;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8018EE50 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8018EE50 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017F7B4;
     extern u16 D_8018EE50;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017F7B0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017F7AC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017F7B8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017F7B0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017F7AC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F7B8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017F7AC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F7B8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8018EE40;
+    a1v = pac[0]; a2v = pac[2];
     D_8018EE50 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8018EE40)) {
     found:
         pb4 = (*(u16 * *)&D_8017F7B4);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017F7AC;
     extern u8 D_8017F7B0;
     extern u8 D_8017F7B8;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017F7B0);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017F7AC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F7B8); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017F7AC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F7B8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8018EE40;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_8018EE50 = 0;
+    ((H16 *)&D_8018EE50)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017F7B4);
         p2[0] = pb4[0];
diff --git a/src/ov_SC01_004/ov_SC01_004_jr_8015C32C.c b/src/ov_SC01_004/ov_SC01_004_jr_8015C32C.c
index 6877682195..3d0ed5fa47 100644
--- a/src/ov_SC01_004/ov_SC01_004_jr_8015C32C.c
+++ b/src/ov_SC01_004/ov_SC01_004_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801818B8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801818B8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC01_005/ov_SC01_005_after.c b/src/ov_SC01_005/ov_SC01_005_after.c
index ced3ec310d..352035e463 100644
--- a/src/ov_SC01_005/ov_SC01_005_after.c
+++ b/src/ov_SC01_005/ov_SC01_005_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80183EA8[];
+    extern s32 (*D_80183EA8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80183EA8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80183EA8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.c b/src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.c
index a80fd34bb4..d0091c7eab 100644
--- a/src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.c
+++ b/src/ov_SC01_005/ov_SC01_005_jr_8012ACE0.c
@@ -1115,156 +1115,136 @@ extern s16 D_80182848[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801827C0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80182820;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801827C0 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182828; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80182820;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80182828 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182848; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80182848 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80182790;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80182790;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2298,15 +2278,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80182944);
     u16 *pB = (*(u16 * *)&D_80182940);
     u16 *pC = (*(u16 * *)&D_8018294C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2317,15 +2297,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2338,10 +2318,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2769,57 +2749,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801CC5B0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801CC5B0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801CC5B0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2930,26 +2905,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80182948;
     extern u16 D_801CC5B0;
 
-    register s16 *pb0 __asm__("$9");   /* D_80182944 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80182940 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018294C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80182944;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80182940; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018294C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80182940; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018294C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801CC5A0;
+    a1v = pac[0]; a2v = pac[2];
     D_801CC5B0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801CC5A0)) {
     found:
         pb4 = (*(u16 * *)&D_80182948);
         ((u16 *)p2)[0] = pb4[0];
@@ -2995,23 +2969,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80182940;
     extern u8 D_80182944;
     extern u8 D_8018294C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80182944);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80182940); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018294C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80182940); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018294C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801CC5A0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801CC5B0 = 0;
+    ((H16 *)&D_801CC5B0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80182948);
         p2[0] = pb4[0];
diff --git a/src/ov_SC01_005/ov_SC01_005_jr_8015C32C.c b/src/ov_SC01_005/ov_SC01_005_jr_8015C32C.c
index c074b66025..73ce8b583e 100644
--- a/src/ov_SC01_005/ov_SC01_005_jr_8015C32C.c
+++ b/src/ov_SC01_005/ov_SC01_005_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80184A4C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80184A4C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC01_008/ov_SC01_008_after.c b/src/ov_SC01_008/ov_SC01_008_after.c
index 8b4e0d6e39..a267f775fa 100644
--- a/src/ov_SC01_008/ov_SC01_008_after.c
+++ b/src/ov_SC01_008/ov_SC01_008_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80181288[];
+    extern s32 (*D_80181288[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80181288[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80181288[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.c b/src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.c
index 80e5b96591..d1d0a3e2c9 100644
--- a/src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.c
+++ b/src/ov_SC01_008/ov_SC01_008_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_8017FC28[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FBA0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017FC00;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017FBA0 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FC08; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017FC00;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017FC08 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FC28; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017FC28 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017FB70;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017FB70;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017FD24);
     u16 *pB = (*(u16 * *)&D_8017FD20);
     u16 *pC = (*(u16 * *)&D_8017FD2C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A2060;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A2060 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A2060 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017FD28;
     extern u16 D_801A2060;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017FD24 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017FD20 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017FD2C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017FD24;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017FD20; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017FD2C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017FD20; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017FD2C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A2050;
+    a1v = pac[0]; a2v = pac[2];
     D_801A2060 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A2050)) {
     found:
         pb4 = (*(u16 * *)&D_8017FD28);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017FD20;
     extern u8 D_8017FD24;
     extern u8 D_8017FD2C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017FD24);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017FD20); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017FD2C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017FD20); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017FD2C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A2050;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801A2060 = 0;
+    ((H16 *)&D_801A2060)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017FD28);
         p2[0] = pb4[0];
diff --git a/src/ov_SC01_008/ov_SC01_008_jr_8015C32C.c b/src/ov_SC01_008/ov_SC01_008_jr_8015C32C.c
index c906ecd54e..d40f167602 100644
--- a/src/ov_SC01_008/ov_SC01_008_jr_8015C32C.c
+++ b/src/ov_SC01_008/ov_SC01_008_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80181E2C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80181E2C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC01_009/ov_SC01_009_after.c b/src/ov_SC01_009/ov_SC01_009_after.c
index c03898040f..4272e047ea 100644
--- a/src/ov_SC01_009/ov_SC01_009_after.c
+++ b/src/ov_SC01_009/ov_SC01_009_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80184470[];
+    extern s32 (*D_80184470[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80184470[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80184470[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.c b/src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.c
index 9688cbc559..ddaa800b0c 100644
--- a/src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.c
+++ b/src/ov_SC01_009/ov_SC01_009_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_80182E10[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182D88; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80182DE8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80182D88 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182DF0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80182DE8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80182DF0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182E10; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80182E10 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80182D58;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80182D58;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80182F0C);
     u16 *pB = (*(u16 * *)&D_80182F08);
     u16 *pC = (*(u16 * *)&D_80182F14);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801F1EC0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801F1EC0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801F1EC0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80182F10;
     extern u16 D_801F1EC0;
 
-    register s16 *pb0 __asm__("$9");   /* D_80182F0C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80182F08 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80182F14 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80182F0C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80182F08; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182F14); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80182F08; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182F14); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801F1EB0;
+    a1v = pac[0]; a2v = pac[2];
     D_801F1EC0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801F1EB0)) {
     found:
         pb4 = (*(u16 * *)&D_80182F10);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80182F08;
     extern u8 D_80182F0C;
     extern u8 D_80182F14;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80182F0C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80182F08); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182F14); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80182F08); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182F14); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801F1EB0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801F1EC0 = 0;
+    ((H16 *)&D_801F1EC0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80182F10);
         p2[0] = pb4[0];
diff --git a/src/ov_SC01_009/ov_SC01_009_jr_8015C32C.c b/src/ov_SC01_009/ov_SC01_009_jr_8015C32C.c
index 812cb1bf65..9089ae3c30 100644
--- a/src/ov_SC01_009/ov_SC01_009_jr_8015C32C.c
+++ b/src/ov_SC01_009/ov_SC01_009_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80185014[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80185014[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC01_074/ov_SC01_074_after.c b/src/ov_SC01_074/ov_SC01_074_after.c
index a3d4d9c53f..e3de47da25 100644
--- a/src/ov_SC01_074/ov_SC01_074_after.c
+++ b/src/ov_SC01_074/ov_SC01_074_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801800F0[];
+    extern s32 (*D_801800F0[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801800F0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801800F0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.c b/src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.c
index 70a83d01a7..5afc4bdf9f 100644
--- a/src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.c
+++ b/src/ov_SC01_074/ov_SC01_074_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_8017EA90[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA08; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017EA68;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017EA08 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA70; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017EA68;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017EA70 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA90; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017EA90 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017E9D8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017E9D8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017EB8C);
     u16 *pB = (*(u16 * *)&D_8017EB88);
     u16 *pC = (*(u16 * *)&D_8017EB94);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019A940;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019A940 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019A940 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017EB90;
     extern u16 D_8019A940;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017EB8C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017EB88 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017EB94 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017EB8C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017EB88; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017EB94); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017EB88; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017EB94); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019A930;
+    a1v = pac[0]; a2v = pac[2];
     D_8019A940 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019A930)) {
     found:
         pb4 = (*(u16 * *)&D_8017EB90);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017EB88;
     extern u8 D_8017EB8C;
     extern u8 D_8017EB94;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017EB8C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017EB88); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017EB94); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017EB88); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017EB94); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019A930;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_8019A940 = 0;
+    ((H16 *)&D_8019A940)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017EB90);
         p2[0] = pb4[0];
diff --git a/src/ov_SC01_074/ov_SC01_074_jr_8015C32C.c b/src/ov_SC01_074/ov_SC01_074_jr_8015C32C.c
index 1adafaab05..5c268139ed 100644
--- a/src/ov_SC01_074/ov_SC01_074_jr_8015C32C.c
+++ b/src/ov_SC01_074/ov_SC01_074_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80180C94[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80180C94[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC01_077/ov_SC01_077_jr_8012ACE0.c b/src/ov_SC01_077/ov_SC01_077_jr_8012ACE0.c
index df4fa3c386..a6bc6cebf4 100644
--- a/src/ov_SC01_077/ov_SC01_077_jr_8012ACE0.c
+++ b/src/ov_SC01_077/ov_SC01_077_jr_8012ACE0.c
@@ -1421,156 +1421,136 @@ extern s16 D_80186FB4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186F2C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80186F8C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80186F2C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186F94; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80186F8C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80186F94 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186FB4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80186FB4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80186EFC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80186EFC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2656,15 +2636,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801870B0);
     u16 *pB = (*(u16 * *)&D_801870AC);
     u16 *pC = (*(u16 * *)&D_801870B8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2675,15 +2655,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2696,10 +2676,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -3160,57 +3140,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801D9500;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801D9500 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801D9500 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -3319,26 +3294,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801870B4;
     extern u16 D_801D9500;
 
-    register s16 *pb0 __asm__("$9");   /* D_801870B0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus1)
-    register s16 *pac __asm__("$6");   /* D_801870AC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801870B8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801870B0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801870AC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801870B8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801870AC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801870B8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801D94F0;
+    a1v = pac[0]; a2v = pac[2];
     D_801D9500 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801D94F0)) {
     found:
         pb4 = (*(u16 * *)&D_801870B4);
         ((u16 *)p2)[0] = pb4[0];
diff --git a/src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c b/src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c
index 6ae5a2dec3..5c33c1f53a 100644
--- a/src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c
+++ b/src/ov_SC01_077/ov_SC01_077_jr_8015C32C.c
@@ -2039,19 +2039,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801891B8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801891B8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC01_080/ov_SC01_080_after.c b/src/ov_SC01_080/ov_SC01_080_after.c
index 688518a368..30202a5260 100644
--- a/src/ov_SC01_080/ov_SC01_080_after.c
+++ b/src/ov_SC01_080/ov_SC01_080_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80185050[];
+    extern s32 (*D_80185050[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80185050[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80185050[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.c b/src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.c
index 74522091cd..3fb4f5f12b 100644
--- a/src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.c
+++ b/src/ov_SC01_080/ov_SC01_080_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_801839F0[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183968; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801839C8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80183968 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801839D0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801839C8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801839D0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801839F0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801839F0 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80183938;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80183938;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80183AEC);
     u16 *pB = (*(u16 * *)&D_80183AE8);
     u16 *pC = (*(u16 * *)&D_80183AF4);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C4770;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C4770 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C4770 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80183AF0;
     extern u16 D_801C4770;
 
-    register s16 *pb0 __asm__("$9");   /* D_80183AEC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80183AE8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80183AF4 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80183AEC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80183AE8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183AF4); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80183AE8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183AF4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801C4760;
+    a1v = pac[0]; a2v = pac[2];
     D_801C4770 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801C4760)) {
     found:
         pb4 = (*(u16 * *)&D_80183AF0);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80183AE8;
     extern u8 D_80183AEC;
     extern u8 D_80183AF4;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80183AEC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80183AE8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80183AF4); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80183AE8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80183AF4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801C4760;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801C4770 = 0;
+    ((H16 *)&D_801C4770)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80183AF0);
         p2[0] = pb4[0];
diff --git a/src/ov_SC01_080/ov_SC01_080_jr_8015C32C.c b/src/ov_SC01_080/ov_SC01_080_jr_8015C32C.c
index f0a5da3066..37deaed832 100644
--- a/src/ov_SC01_080/ov_SC01_080_jr_8015C32C.c
+++ b/src/ov_SC01_080/ov_SC01_080_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80185BF4[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80185BF4[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC01_084/ov_SC01_084_after.c b/src/ov_SC01_084/ov_SC01_084_after.c
index 21ff960a69..1aca0fb8f1 100644
--- a/src/ov_SC01_084/ov_SC01_084_after.c
+++ b/src/ov_SC01_084/ov_SC01_084_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80188344[];
+    extern s32 (*D_80188344[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80188344[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80188344[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.c b/src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.c
index b0988e997a..c56e00ca84 100644
--- a/src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.c
+++ b/src/ov_SC01_084/ov_SC01_084_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_80186CE4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186C5C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80186CBC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80186C5C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186CC4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80186CBC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80186CC4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186CE4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80186CE4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80186C2C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80186C2C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80186DE0);
     u16 *pB = (*(u16 * *)&D_80186DDC);
     u16 *pC = (*(u16 * *)&D_80186DE8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C6218;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C6218 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C6218 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80186DE4;
     extern u16 D_801C6218;
 
-    register s16 *pb0 __asm__("$9");   /* D_80186DE0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80186DDC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80186DE8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80186DE0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80186DDC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186DE8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80186DDC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186DE8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801C6208;
+    a1v = pac[0]; a2v = pac[2];
     D_801C6218 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801C6208)) {
     found:
         pb4 = (*(u16 * *)&D_80186DE4);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80186DDC;
     extern u8 D_80186DE0;
     extern u8 D_80186DE8;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80186DE0);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80186DDC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186DE8); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80186DDC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186DE8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801C6208;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801C6218 = 0;
+    ((H16 *)&D_801C6218)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80186DE4);
         p2[0] = pb4[0];
diff --git a/src/ov_SC01_084/ov_SC01_084_jr_8015C32C.c b/src/ov_SC01_084/ov_SC01_084_jr_8015C32C.c
index 21bace51a8..b65c48fa8a 100644
--- a/src/ov_SC01_084/ov_SC01_084_jr_8015C32C.c
+++ b/src/ov_SC01_084/ov_SC01_084_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80188EE8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80188EE8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_000/ov_SC02_000_after.c b/src/ov_SC02_000/ov_SC02_000_after.c
index f25f8f44de..ed7f6075a3 100644
--- a/src/ov_SC02_000/ov_SC02_000_after.c
+++ b/src/ov_SC02_000/ov_SC02_000_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018C6F4[];
+    extern s32 (*D_8018C6F4[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018C6F4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018C6F4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.c b/src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.c
index 0d8f70209e..d538781166 100644
--- a/src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.c
+++ b/src/ov_SC02_000/ov_SC02_000_jr_8012ACE0.c
@@ -1120,156 +1120,136 @@ extern s16 D_8018B094[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B00C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018B06C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018B00C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B074; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018B06C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018B074 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B094; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018B094 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018AFDC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018AFDC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2303,15 +2283,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018B190);
     u16 *pB = (*(u16 * *)&D_8018B18C);
     u16 *pC = (*(u16 * *)&D_8018B198);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2322,15 +2302,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2343,10 +2323,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2774,57 +2754,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801E6D48;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801E6D48 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801E6D48 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2935,26 +2910,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018B194;
     extern u16 D_801E6D48;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018B190 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018B18C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018B198 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018B190;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018B18C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B198); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018B18C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B198); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801E6D38;
+    a1v = pac[0]; a2v = pac[2];
     D_801E6D48 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801E6D38)) {
     found:
         pb4 = (*(u16 * *)&D_8018B194);
         ((u16 *)p2)[0] = pb4[0];
@@ -3000,23 +2974,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018B18C;
     extern u8 D_8018B190;
     extern u8 D_8018B198;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018B190);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018B18C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018B198); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018B18C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018B198); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801E6D38;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801E6D48 = 0;
+    ((H16 *)&D_801E6D48)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018B194);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_000/ov_SC02_000_jr_8015C32C.c b/src/ov_SC02_000/ov_SC02_000_jr_8015C32C.c
index f5d3ff0e92..7ac2e1d30c 100644
--- a/src/ov_SC02_000/ov_SC02_000_jr_8015C32C.c
+++ b/src/ov_SC02_000/ov_SC02_000_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018D298[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018D298[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_004/ov_SC02_004_after.c b/src/ov_SC02_004/ov_SC02_004_after.c
index 410a0cf351..262e0e9287 100644
--- a/src/ov_SC02_004/ov_SC02_004_after.c
+++ b/src/ov_SC02_004/ov_SC02_004_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8017F7D4[];
+    extern s32 (*D_8017F7D4[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8017F7D4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8017F7D4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.c b/src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.c
index 350b098271..a02d4042f6 100644
--- a/src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.c
+++ b/src/ov_SC02_004/ov_SC02_004_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_8017E174[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E0EC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017E14C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017E0EC + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E154; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017E14C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017E154 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E174; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017E174 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017E0BC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017E0BC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017E270);
     u16 *pB = (*(u16 * *)&D_8017E26C);
     u16 *pC = (*(u16 * *)&D_8017E278);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_80194F98;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_80194F98 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_80194F98 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017E274;
     extern u16 D_80194F98;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017E270 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017E26C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017E278 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017E270;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017E26C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E278); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017E26C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E278); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80194F88;
+    a1v = pac[0]; a2v = pac[2];
     D_80194F98 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80194F88)) {
     found:
         pb4 = (*(u16 * *)&D_8017E274);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017E26C;
     extern u8 D_8017E270;
     extern u8 D_8017E278;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017E270);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017E26C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E278); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017E26C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E278); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80194F88;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_80194F98 = 0;
+    ((H16 *)&D_80194F98)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017E274);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_004/ov_SC02_004_jr_8015C32C.c b/src/ov_SC02_004/ov_SC02_004_jr_8015C32C.c
index 14be6cfe26..5de06fb105 100644
--- a/src/ov_SC02_004/ov_SC02_004_jr_8015C32C.c
+++ b/src/ov_SC02_004/ov_SC02_004_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80180378[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80180378[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_005/ov_SC02_005_after.c b/src/ov_SC02_005/ov_SC02_005_after.c
index 2bb40db62b..712be2a776 100644
--- a/src/ov_SC02_005/ov_SC02_005_after.c
+++ b/src/ov_SC02_005/ov_SC02_005_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801923D8[];
+    extern s32 (*D_801923D8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801923D8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801923D8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.c b/src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.c
index 7ceed975bd..e2247b965a 100644
--- a/src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.c
+++ b/src/ov_SC02_005/ov_SC02_005_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_80190D78[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80190CF0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80190D50;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80190CF0 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80190D58; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80190D50;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80190D58 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80190D78; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80190D78 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80190CC0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80190CC0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80190E74);
     u16 *pB = (*(u16 * *)&D_80190E70);
     u16 *pC = (*(u16 * *)&D_80190E7C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801E3010;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801E3010 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801E3010 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80190E78;
     extern u16 D_801E3010;
 
-    register s16 *pb0 __asm__("$9");   /* D_80190E74 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80190E70 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80190E7C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80190E74;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80190E70; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80190E7C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80190E70; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80190E7C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801E3000;
+    a1v = pac[0]; a2v = pac[2];
     D_801E3010 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801E3000)) {
     found:
         pb4 = (*(u16 * *)&D_80190E78);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80190E70;
     extern u8 D_80190E74;
     extern u8 D_80190E7C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80190E74);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80190E70); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80190E7C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80190E70); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80190E7C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801E3000;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801E3010 = 0;
+    ((H16 *)&D_801E3010)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80190E78);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_005/ov_SC02_005_jr_8015C32C.c b/src/ov_SC02_005/ov_SC02_005_jr_8015C32C.c
index c5c0462698..799cac1a24 100644
--- a/src/ov_SC02_005/ov_SC02_005_jr_8015C32C.c
+++ b/src/ov_SC02_005/ov_SC02_005_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80192F7C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80192F7C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_011/ov_SC02_011_after.c b/src/ov_SC02_011/ov_SC02_011_after.c
index 60c1ac08e5..b4547a1fa0 100644
--- a/src/ov_SC02_011/ov_SC02_011_after.c
+++ b/src/ov_SC02_011/ov_SC02_011_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80192828[];
+    extern s32 (*D_80192828[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80192828[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80192828[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.c b/src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.c
index 5652dfe4be..f5794587d4 100644
--- a/src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.c
+++ b/src/ov_SC02_011/ov_SC02_011_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_801911C8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80191140; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801911A0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80191140 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801911A8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801911A0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801911A8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801911C8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801911C8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80191110;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80191110;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801912C4);
     u16 *pB = (*(u16 * *)&D_801912C0);
     u16 *pC = (*(u16 * *)&D_801912CC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801E9EF0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801E9EF0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801E9EF0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801912C8;
     extern u16 D_801E9EF0;
 
-    register s16 *pb0 __asm__("$9");   /* D_801912C4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801912C0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801912CC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801912C4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801912C0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801912CC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801912C0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801912CC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801E9EE0;
+    a1v = pac[0]; a2v = pac[2];
     D_801E9EF0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801E9EE0)) {
     found:
         pb4 = (*(u16 * *)&D_801912C8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801912C0;
     extern u8 D_801912C4;
     extern u8 D_801912CC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801912C4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801912C0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801912CC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801912C0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801912CC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801E9EE0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801E9EF0 = 0;
+    ((H16 *)&D_801E9EF0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801912C8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_011/ov_SC02_011_jr_8015C32C.c b/src/ov_SC02_011/ov_SC02_011_jr_8015C32C.c
index 9a63dea15f..fcdb6819e3 100644
--- a/src/ov_SC02_011/ov_SC02_011_jr_8015C32C.c
+++ b/src/ov_SC02_011/ov_SC02_011_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801933CC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801933CC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_015/ov_SC02_015_after.c b/src/ov_SC02_015/ov_SC02_015_after.c
index 0d30e04a83..ed979df1b4 100644
--- a/src/ov_SC02_015/ov_SC02_015_after.c
+++ b/src/ov_SC02_015/ov_SC02_015_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8017FD3C[];
+    extern s32 (*D_8017FD3C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8017FD3C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8017FD3C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.c b/src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.c
index 18008eacdd..ec991e3a17 100644
--- a/src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.c
+++ b/src/ov_SC02_015/ov_SC02_015_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_8017E6DC[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E654; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017E6B4;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017E654 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E6BC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017E6B4;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017E6BC + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E6DC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017E6DC + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017E624;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017E624;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017E7D8);
     u16 *pB = (*(u16 * *)&D_8017E7D4);
     u16 *pC = (*(u16 * *)&D_8017E7E0);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8018F070;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8018F070 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8018F070 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017E7DC;
     extern u16 D_8018F070;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017E7D8 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017E7D4 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017E7E0 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017E7D8;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017E7D4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E7E0); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017E7D4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E7E0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8018F060;
+    a1v = pac[0]; a2v = pac[2];
     D_8018F070 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8018F060)) {
     found:
         pb4 = (*(u16 * *)&D_8017E7DC);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017E7D4;
     extern u8 D_8017E7D8;
     extern u8 D_8017E7E0;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017E7D8);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017E7D4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E7E0); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017E7D4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E7E0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8018F060;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_8018F070 = 0;
+    ((H16 *)&D_8018F070)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017E7DC);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_015/ov_SC02_015_jr_8015C32C.c b/src/ov_SC02_015/ov_SC02_015_jr_8015C32C.c
index 96813ce1cd..f6d091f3ec 100644
--- a/src/ov_SC02_015/ov_SC02_015_jr_8015C32C.c
+++ b/src/ov_SC02_015/ov_SC02_015_jr_8015C32C.c
@@ -1948,19 +1948,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801808E0[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801808E0[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_016/ov_SC02_016_after.c b/src/ov_SC02_016/ov_SC02_016_after.c
index c74c0e9f91..f077f17ab9 100644
--- a/src/ov_SC02_016/ov_SC02_016_after.c
+++ b/src/ov_SC02_016/ov_SC02_016_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80185F74[];
+    extern s32 (*D_80185F74[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80185F74[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80185F74[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.c b/src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.c
index 714c6be588..9d0b6e68e2 100644
--- a/src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.c
+++ b/src/ov_SC02_016/ov_SC02_016_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_80184914[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018488C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801848EC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018488C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801848F4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801848EC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801848F4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184914; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80184914 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018485C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018485C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80184A10);
     u16 *pB = (*(u16 * *)&D_80184A0C);
     u16 *pC = (*(u16 * *)&D_80184A18);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B2C88;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B2C88 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B2C88 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80184A14;
     extern u16 D_801B2C88;
 
-    register s16 *pb0 __asm__("$9");   /* D_80184A10 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80184A0C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80184A18 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80184A10;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80184A0C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184A18); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80184A0C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184A18); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B2C78;
+    a1v = pac[0]; a2v = pac[2];
     D_801B2C88 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B2C78)) {
     found:
         pb4 = (*(u16 * *)&D_80184A14);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80184A0C;
     extern u8 D_80184A10;
     extern u8 D_80184A18;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80184A10);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80184A0C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184A18); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80184A0C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184A18); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B2C78;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801B2C88 = 0;
+    ((H16 *)&D_801B2C88)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80184A14);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_016/ov_SC02_016_jr_8015C32C.c b/src/ov_SC02_016/ov_SC02_016_jr_8015C32C.c
index 9359164364..99132c4352 100644
--- a/src/ov_SC02_016/ov_SC02_016_jr_8015C32C.c
+++ b/src/ov_SC02_016/ov_SC02_016_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80186B18[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80186B18[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_017/ov_SC02_017_after.c b/src/ov_SC02_017/ov_SC02_017_after.c
index 50de509353..a13c0982b2 100644
--- a/src/ov_SC02_017/ov_SC02_017_after.c
+++ b/src/ov_SC02_017/ov_SC02_017_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018BFCC[];
+    extern s32 (*D_8018BFCC[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018BFCC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018BFCC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.c b/src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.c
index 0a4fea562b..a85844903d 100644
--- a/src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.c
+++ b/src/ov_SC02_017/ov_SC02_017_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_8018A96C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A8E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018A944;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018A8E4 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A94C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018A944;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018A94C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A96C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018A96C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018A8B4;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018A8B4;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018AA68);
     u16 *pB = (*(u16 * *)&D_8018AA64);
     u16 *pC = (*(u16 * *)&D_8018AA70);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801EE4B0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801EE4B0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801EE4B0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018AA6C;
     extern u16 D_801EE4B0;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018AA68 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018AA64 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018AA70 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018AA68;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018AA64; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018AA70); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018AA64; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018AA70); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801EE4A0;
+    a1v = pac[0]; a2v = pac[2];
     D_801EE4B0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801EE4A0)) {
     found:
         pb4 = (*(u16 * *)&D_8018AA6C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018AA64;
     extern u8 D_8018AA68;
     extern u8 D_8018AA70;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018AA68);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018AA64); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018AA70); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018AA64); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018AA70); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801EE4A0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801EE4B0 = 0;
+    ((H16 *)&D_801EE4B0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018AA6C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_017/ov_SC02_017_jr_8015C32C.c b/src/ov_SC02_017/ov_SC02_017_jr_8015C32C.c
index 05bafa8e4a..9e7762a9e3 100644
--- a/src/ov_SC02_017/ov_SC02_017_jr_8015C32C.c
+++ b/src/ov_SC02_017/ov_SC02_017_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018CB70[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018CB70[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_021/ov_SC02_021_after.c b/src/ov_SC02_021/ov_SC02_021_after.c
index 6d2489fde8..8a3c746fbc 100644
--- a/src/ov_SC02_021/ov_SC02_021_after.c
+++ b/src/ov_SC02_021/ov_SC02_021_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801815C0[];
+    extern s32 (*D_801815C0[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801815C0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801815C0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.c b/src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.c
index 2df6e22fba..e671b8d884 100644
--- a/src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.c
+++ b/src/ov_SC02_021/ov_SC02_021_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_8017FF60[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FED8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017FF38;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017FED8 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FF40; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017FF38;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017FF40 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FF60; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017FF60 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017FEA8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017FEA8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018005C);
     u16 *pB = (*(u16 * *)&D_80180058);
     u16 *pC = (*(u16 * *)&D_80180064);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_80191A20;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_80191A20 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_80191A20 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80180060;
     extern u16 D_80191A20;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018005C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80180058 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80180064 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018005C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80180058; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180064); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80180058; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180064); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80191A10;
+    a1v = pac[0]; a2v = pac[2];
     D_80191A20 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80191A10)) {
     found:
         pb4 = (*(u16 * *)&D_80180060);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80180058;
     extern u8 D_8018005C;
     extern u8 D_80180064;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018005C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80180058); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80180064); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80180058); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80180064); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80191A10;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_80191A20 = 0;
+    ((H16 *)&D_80191A20)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80180060);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_021/ov_SC02_021_jr_8015C32C.c b/src/ov_SC02_021/ov_SC02_021_jr_8015C32C.c
index c833170ec0..ac5cfb213e 100644
--- a/src/ov_SC02_021/ov_SC02_021_jr_8015C32C.c
+++ b/src/ov_SC02_021/ov_SC02_021_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80182164[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80182164[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_026/ov_SC02_026_after.c b/src/ov_SC02_026/ov_SC02_026_after.c
index ba51cc45ff..3f4dd19d07 100644
--- a/src/ov_SC02_026/ov_SC02_026_after.c
+++ b/src/ov_SC02_026/ov_SC02_026_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80187C14[];
+    extern s32 (*D_80187C14[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80187C14[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80187C14[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.c b/src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.c
index f3c68730fe..859f70b8f8 100644
--- a/src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.c
+++ b/src/ov_SC02_026/ov_SC02_026_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_801865B4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018652C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018658C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018652C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186594; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018658C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80186594 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801865B4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801865B4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801864FC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801864FC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801866B0);
     u16 *pB = (*(u16 * *)&D_801866AC);
     u16 *pC = (*(u16 * *)&D_801866B8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801CEE60;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801CEE60 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801CEE60 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801866B4;
     extern u16 D_801CEE60;
 
-    register s16 *pb0 __asm__("$9");   /* D_801866B0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801866AC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801866B8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801866B0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801866AC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801866B8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801866AC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801866B8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801CEE50;
+    a1v = pac[0]; a2v = pac[2];
     D_801CEE60 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801CEE50)) {
     found:
         pb4 = (*(u16 * *)&D_801866B4);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801866AC;
     extern u8 D_801866B0;
     extern u8 D_801866B8;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801866B0);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801866AC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801866B8); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801866AC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801866B8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801CEE50;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801CEE60 = 0;
+    ((H16 *)&D_801CEE60)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801866B4);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_026/ov_SC02_026_jr_8015C32C.c b/src/ov_SC02_026/ov_SC02_026_jr_8015C32C.c
index cd5b1d8c29..d55e45abb3 100644
--- a/src/ov_SC02_026/ov_SC02_026_jr_8015C32C.c
+++ b/src/ov_SC02_026/ov_SC02_026_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801887B8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801887B8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_027/ov_SC02_027_after.c b/src/ov_SC02_027/ov_SC02_027_after.c
index fc902f1927..62cb8b37b2 100644
--- a/src/ov_SC02_027/ov_SC02_027_after.c
+++ b/src/ov_SC02_027/ov_SC02_027_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018CD38[];
+    extern s32 (*D_8018CD38[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018CD38[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018CD38[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.c b/src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.c
index ef94d16565..420ba1ea75 100644
--- a/src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.c
+++ b/src/ov_SC02_027/ov_SC02_027_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_8018B6D8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B650; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018B6B0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018B650 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B6B8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018B6B0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018B6B8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B6D8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018B6D8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018B620;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018B620;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018B7D4);
     u16 *pB = (*(u16 * *)&D_8018B7D0);
     u16 *pC = (*(u16 * *)&D_8018B7DC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801D8BD0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801D8BD0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801D8BD0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018B7D8;
     extern u16 D_801D8BD0;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018B7D4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018B7D0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018B7DC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018B7D4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018B7D0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B7DC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018B7D0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B7DC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801D8BC0;
+    a1v = pac[0]; a2v = pac[2];
     D_801D8BD0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801D8BC0)) {
     found:
         pb4 = (*(u16 * *)&D_8018B7D8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018B7D0;
     extern u8 D_8018B7D4;
     extern u8 D_8018B7DC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018B7D4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018B7D0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018B7DC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018B7D0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018B7DC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801D8BC0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801D8BD0 = 0;
+    ((H16 *)&D_801D8BD0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018B7D8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_027/ov_SC02_027_jr_8015C32C.c b/src/ov_SC02_027/ov_SC02_027_jr_8015C32C.c
index 056e758015..1a30b13e9b 100644
--- a/src/ov_SC02_027/ov_SC02_027_jr_8015C32C.c
+++ b/src/ov_SC02_027/ov_SC02_027_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018D8DC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018D8DC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_028/ov_SC02_028_after.c b/src/ov_SC02_028/ov_SC02_028_after.c
index 3a5d309a9e..f1a87c9a08 100644
--- a/src/ov_SC02_028/ov_SC02_028_after.c
+++ b/src/ov_SC02_028/ov_SC02_028_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018CF3C[];
+    extern s32 (*D_8018CF3C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018CF3C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018CF3C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.c b/src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.c
index 1a7a65d2db..58987ae1ce 100644
--- a/src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.c
+++ b/src/ov_SC02_028/ov_SC02_028_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_8018B8DC[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B854; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018B8B4;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018B854 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B8BC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018B8B4;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018B8BC + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B8DC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018B8DC + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018B824;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018B824;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018B9D8);
     u16 *pB = (*(u16 * *)&D_8018B9D4);
     u16 *pC = (*(u16 * *)&D_8018B9E0);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801D1B70;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801D1B70 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801D1B70 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018B9DC;
     extern u16 D_801D1B70;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018B9D8 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018B9D4 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018B9E0 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018B9D8;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018B9D4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B9E0); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018B9D4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B9E0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801D1B60;
+    a1v = pac[0]; a2v = pac[2];
     D_801D1B70 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801D1B60)) {
     found:
         pb4 = (*(u16 * *)&D_8018B9DC);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018B9D4;
     extern u8 D_8018B9D8;
     extern u8 D_8018B9E0;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018B9D8);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018B9D4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018B9E0); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018B9D4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018B9E0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801D1B60;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801D1B70 = 0;
+    ((H16 *)&D_801D1B70)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018B9DC);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_028/ov_SC02_028_jr_8015C32C.c b/src/ov_SC02_028/ov_SC02_028_jr_8015C32C.c
index 2c47d6f92e..0bd431abbe 100644
--- a/src/ov_SC02_028/ov_SC02_028_jr_8015C32C.c
+++ b/src/ov_SC02_028/ov_SC02_028_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018DAE0[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018DAE0[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_031/ov_SC02_031_after.c b/src/ov_SC02_031/ov_SC02_031_after.c
index 51b32a3f19..bd9f5dd66a 100644
--- a/src/ov_SC02_031/ov_SC02_031_after.c
+++ b/src/ov_SC02_031/ov_SC02_031_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80186768[];
+    extern s32 (*D_80186768[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80186768[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80186768[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.c b/src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.c
index a6f288e68c..0eae1d22fd 100644
--- a/src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.c
+++ b/src/ov_SC02_031/ov_SC02_031_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_80185108[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185080; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801850E0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80185080 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801850E8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801850E0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801850E8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185108; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80185108 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80185050;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80185050;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80185204);
     u16 *pB = (*(u16 * *)&D_80185200);
     u16 *pC = (*(u16 * *)&D_8018520C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B62E8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B62E8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B62E8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80185208;
     extern u16 D_801B62E8;
 
-    register s16 *pb0 __asm__("$9");   /* D_80185204 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80185200 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018520C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80185204;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80185200; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018520C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80185200; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018520C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B62D8;
+    a1v = pac[0]; a2v = pac[2];
     D_801B62E8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B62D8)) {
     found:
         pb4 = (*(u16 * *)&D_80185208);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80185200;
     extern u8 D_80185204;
     extern u8 D_8018520C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80185204);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80185200); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018520C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80185200); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018520C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B62D8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801B62E8 = 0;
+    ((H16 *)&D_801B62E8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80185208);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_031/ov_SC02_031_jr_8015C32C.c b/src/ov_SC02_031/ov_SC02_031_jr_8015C32C.c
index 585a75536d..26473609b1 100644
--- a/src/ov_SC02_031/ov_SC02_031_jr_8015C32C.c
+++ b/src/ov_SC02_031/ov_SC02_031_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018730C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018730C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_035/ov_SC02_035_after.c b/src/ov_SC02_035/ov_SC02_035_after.c
index f133c3ceb2..c9d34e0f6c 100644
--- a/src/ov_SC02_035/ov_SC02_035_after.c
+++ b/src/ov_SC02_035/ov_SC02_035_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80185FC8[];
+    extern s32 (*D_80185FC8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80185FC8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80185FC8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.c b/src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.c
index 4f0d47c542..63e6c752bb 100644
--- a/src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.c
+++ b/src/ov_SC02_035/ov_SC02_035_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_80184968[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801848E0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80184940;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801848E0 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184948; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80184940;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80184948 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184968; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80184968 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801848B0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801848B0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2306,15 +2286,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80184A64);
     u16 *pB = (*(u16 * *)&D_80184A60);
     u16 *pC = (*(u16 * *)&D_80184A6C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2325,15 +2305,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2346,10 +2326,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2777,57 +2757,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801BD618;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801BD618 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801BD618 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2938,26 +2913,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80184A68;
     extern u16 D_801BD618;
 
-    register s16 *pb0 __asm__("$9");   /* D_80184A64 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80184A60 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80184A6C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80184A64;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80184A60; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184A6C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80184A60; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184A6C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801BD608;
+    a1v = pac[0]; a2v = pac[2];
     D_801BD618 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801BD608)) {
     found:
         pb4 = (*(u16 * *)&D_80184A68);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,23 +2977,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80184A60;
     extern u8 D_80184A64;
     extern u8 D_80184A6C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80184A64);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80184A60); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184A6C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80184A60); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184A6C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801BD608;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801BD618 = 0;
+    ((H16 *)&D_801BD618)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80184A68);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_035/ov_SC02_035_jr_8015C32C.c b/src/ov_SC02_035/ov_SC02_035_jr_8015C32C.c
index ac3eb4f15d..2738149d7e 100644
--- a/src/ov_SC02_035/ov_SC02_035_jr_8015C32C.c
+++ b/src/ov_SC02_035/ov_SC02_035_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80186B6C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80186B6C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_037/ov_SC02_037_jr_80131340.c b/src/ov_SC02_037/ov_SC02_037_jr_80131340.c
index 840bf955fd..57c3e587f2 100644
--- a/src/ov_SC02_037/ov_SC02_037_jr_80131340.c
+++ b/src/ov_SC02_037/ov_SC02_037_jr_80131340.c
@@ -1530,15 +1530,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801841A0);
     u16 *pB = (*(u16 * *)&D_8018419C);
     u16 *pC = (*(u16 * *)&D_801841A8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -1549,15 +1549,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -1570,10 +1570,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2001,57 +2001,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C8428;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C8428 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C8428 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
diff --git a/src/ov_SC02_037/ov_SC02_037_jr_801458E0.c b/src/ov_SC02_037/ov_SC02_037_jr_801458E0.c
index 012bbd0706..7297f14c97 100644
--- a/src/ov_SC02_037/ov_SC02_037_jr_801458E0.c
+++ b/src/ov_SC02_037/ov_SC02_037_jr_801458E0.c
@@ -1905,38 +1905,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80185704[];
+    extern s32 (*D_80185704[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80185704[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80185704[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_039/ov_SC02_039_after.c b/src/ov_SC02_039/ov_SC02_039_after.c
index 68cddbeca9..2a4c81cafe 100644
--- a/src/ov_SC02_039/ov_SC02_039_after.c
+++ b/src/ov_SC02_039/ov_SC02_039_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80180BF4[];
+    extern s32 (*D_80180BF4[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80180BF4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80180BF4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.c b/src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.c
index 08f35f858c..04cc2efb63 100644
--- a/src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.c
+++ b/src/ov_SC02_039/ov_SC02_039_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017F594[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F50C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017F56C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017F50C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F574; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017F56C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017F574 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F594; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017F594 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017F4DC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017F4DC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017F690);
     u16 *pB = (*(u16 * *)&D_8017F68C);
     u16 *pC = (*(u16 * *)&D_8017F698);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019F9C8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019F9C8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019F9C8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017F694;
     extern u16 D_8019F9C8;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017F690 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017F68C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017F698 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017F690;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017F68C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F698); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017F68C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F698); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019F9B8;
+    a1v = pac[0]; a2v = pac[2];
     D_8019F9C8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019F9B8)) {
     found:
         pb4 = (*(u16 * *)&D_8017F694);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017F68C;
     extern u8 D_8017F690;
     extern u8 D_8017F698;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017F690);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017F68C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F698); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017F68C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F698); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019F9B8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_8019F9C8 = 0;
+    ((H16 *)&D_8019F9C8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017F694);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_039/ov_SC02_039_jr_8015C32C.c b/src/ov_SC02_039/ov_SC02_039_jr_8015C32C.c
index 5490ae55de..356d3f600e 100644
--- a/src/ov_SC02_039/ov_SC02_039_jr_8015C32C.c
+++ b/src/ov_SC02_039/ov_SC02_039_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80181798[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80181798[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC02_041/ov_SC02_041_after.c b/src/ov_SC02_041/ov_SC02_041_after.c
index 95c723d603..ab97c86c7d 100644
--- a/src/ov_SC02_041/ov_SC02_041_after.c
+++ b/src/ov_SC02_041/ov_SC02_041_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801868C4[];
+    extern s32 (*D_801868C4[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801868C4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801868C4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.c b/src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.c
index 5cca087457..60c2c8e4c9 100644
--- a/src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.c
+++ b/src/ov_SC02_041/ov_SC02_041_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80185264[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801851DC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018523C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801851DC + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185244; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018523C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80185244 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185264; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80185264 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801851AC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801851AC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80185360);
     u16 *pB = (*(u16 * *)&D_8018535C);
     u16 *pC = (*(u16 * *)&D_80185368);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B7D40;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B7D40 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B7D40 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80185364;
     extern u16 D_801B7D40;
 
-    register s16 *pb0 __asm__("$9");   /* D_80185360 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018535C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80185368 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80185360;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018535C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185368); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018535C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185368); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B7D30;
+    a1v = pac[0]; a2v = pac[2];
     D_801B7D40 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B7D30)) {
     found:
         pb4 = (*(u16 * *)&D_80185364);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018535C;
     extern u8 D_80185360;
     extern u8 D_80185368;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80185360);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018535C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80185368); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018535C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80185368); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B7D30;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801B7D40 = 0;
+    ((H16 *)&D_801B7D40)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80185364);
         p2[0] = pb4[0];
diff --git a/src/ov_SC02_041/ov_SC02_041_jr_8015C32C.c b/src/ov_SC02_041/ov_SC02_041_jr_8015C32C.c
index fed176896f..ca05431a12 100644
--- a/src/ov_SC02_041/ov_SC02_041_jr_8015C32C.c
+++ b/src/ov_SC02_041/ov_SC02_041_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80187468[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80187468[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_001/ov_SC03_001_after.c b/src/ov_SC03_001/ov_SC03_001_after.c
index 146ee2f9e7..d69969abb9 100644
--- a/src/ov_SC03_001/ov_SC03_001_after.c
+++ b/src/ov_SC03_001/ov_SC03_001_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018F004[];
+    extern s32 (*D_8018F004[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018F004[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018F004[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.c b/src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.c
index b527721dca..34fd3678ce 100644
--- a/src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.c
+++ b/src/ov_SC03_001/ov_SC03_001_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_8018D9A4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D91C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018D97C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018D91C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D984; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018D97C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018D984 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D9A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018D9A4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018D8EC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018D8EC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2305,15 +2285,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018DAA0);
     u16 *pB = (*(u16 * *)&D_8018DA9C);
     u16 *pC = (*(u16 * *)&D_8018DAA8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2324,15 +2304,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2345,10 +2325,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2776,57 +2756,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801ED3C0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801ED3C0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801ED3C0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2937,26 +2912,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018DAA4;
     extern u16 D_801ED3C0;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018DAA0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018DA9C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018DAA8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018DAA0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018DA9C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018DAA8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018DA9C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018DAA8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801ED3B0;
+    a1v = pac[0]; a2v = pac[2];
     D_801ED3C0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801ED3B0)) {
     found:
         pb4 = (*(u16 * *)&D_8018DAA4);
         ((u16 *)p2)[0] = pb4[0];
@@ -3002,23 +2976,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018DA9C;
     extern u8 D_8018DAA0;
     extern u8 D_8018DAA8;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018DAA0);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018DA9C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018DAA8); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018DA9C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018DAA8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801ED3B0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801ED3C0 = 0;
+    ((H16 *)&D_801ED3C0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018DAA4);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_001/ov_SC03_001_jr_8015C32C.c b/src/ov_SC03_001/ov_SC03_001_jr_8015C32C.c
index 18fd589d0c..fa4d2a44b7 100644
--- a/src/ov_SC03_001/ov_SC03_001_jr_8015C32C.c
+++ b/src/ov_SC03_001/ov_SC03_001_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018FBA8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018FBA8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_002/ov_SC03_002_after.c b/src/ov_SC03_002/ov_SC03_002_after.c
index 926acb44ce..2dc7440a34 100644
--- a/src/ov_SC03_002/ov_SC03_002_after.c
+++ b/src/ov_SC03_002/ov_SC03_002_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80186FF4[];
+    extern s32 (*D_80186FF4[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80186FF4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80186FF4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.c b/src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.c
index 05bb8f9c22..2a21fae4f3 100644
--- a/src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.c
+++ b/src/ov_SC03_002/ov_SC03_002_jr_8012ACE0.c
@@ -1126,156 +1126,136 @@ extern s16 D_80185994[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018590C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018596C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018590C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185974; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018596C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80185974 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185994; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80185994 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801858DC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801858DC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2309,15 +2289,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80185A90);
     u16 *pB = (*(u16 * *)&D_80185A8C);
     u16 *pC = (*(u16 * *)&D_80185A98);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2328,15 +2308,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2349,10 +2329,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2780,57 +2760,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801CA440;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801CA440 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801CA440 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2941,26 +2916,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80185A94;
     extern u16 D_801CA440;
 
-    register s16 *pb0 __asm__("$9");   /* D_80185A90 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80185A8C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80185A98 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80185A90;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80185A8C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185A98); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80185A8C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185A98); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801CA430;
+    a1v = pac[0]; a2v = pac[2];
     D_801CA440 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801CA430)) {
     found:
         pb4 = (*(u16 * *)&D_80185A94);
         ((u16 *)p2)[0] = pb4[0];
@@ -3006,23 +2980,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80185A8C;
     extern u8 D_80185A90;
     extern u8 D_80185A98;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80185A90);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80185A8C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80185A98); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80185A8C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80185A98); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801CA430;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801CA440 = 0;
+    ((H16 *)&D_801CA440)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80185A94);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_002/ov_SC03_002_jr_8015C32C.c b/src/ov_SC03_002/ov_SC03_002_jr_8015C32C.c
index 8112c17d16..06acdda4a8 100644
--- a/src/ov_SC03_002/ov_SC03_002_jr_8015C32C.c
+++ b/src/ov_SC03_002/ov_SC03_002_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80187B98[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80187B98[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_003/ov_SC03_003_after.c b/src/ov_SC03_003/ov_SC03_003_after.c
index e1adfba4f2..4af833f1b9 100644
--- a/src/ov_SC03_003/ov_SC03_003_after.c
+++ b/src/ov_SC03_003/ov_SC03_003_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80180DBC[];
+    extern s32 (*D_80180DBC[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80180DBC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80180DBC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.c b/src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.c
index 4174750707..cd1913d42c 100644
--- a/src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.c
+++ b/src/ov_SC03_003/ov_SC03_003_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017F75C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F6D4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017F734;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017F6D4 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F73C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017F734;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017F73C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F75C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017F75C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017F6A4;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017F6A4;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017F858);
     u16 *pB = (*(u16 * *)&D_8017F854);
     u16 *pC = (*(u16 * *)&D_8017F860);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8018E748;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8018E748 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8018E748 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017F85C;
     extern u16 D_8018E748;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017F858 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017F854 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017F860 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017F858;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017F854; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F860); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017F854; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F860); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8018E738;
+    a1v = pac[0]; a2v = pac[2];
     D_8018E748 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8018E738)) {
     found:
         pb4 = (*(u16 * *)&D_8017F85C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017F854;
     extern u8 D_8017F858;
     extern u8 D_8017F860;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017F858);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017F854); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F860); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017F854); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F860); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8018E738;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_8018E748 = 0;
+    ((H16 *)&D_8018E748)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017F85C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_003/ov_SC03_003_jr_8015C32C.c b/src/ov_SC03_003/ov_SC03_003_jr_8015C32C.c
index 169ad0eb76..35b6baa943 100644
--- a/src/ov_SC03_003/ov_SC03_003_jr_8015C32C.c
+++ b/src/ov_SC03_003/ov_SC03_003_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80181960[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80181960[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_006/ov_SC03_006_after.c b/src/ov_SC03_006/ov_SC03_006_after.c
index 80f786bc0a..4cfc1a25c7 100644
--- a/src/ov_SC03_006/ov_SC03_006_after.c
+++ b/src/ov_SC03_006/ov_SC03_006_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018E0D8[];
+    extern s32 (*D_8018E0D8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018E0D8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018E0D8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.c b/src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.c
index 0d316de926..dc21bf6735 100644
--- a/src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.c
+++ b/src/ov_SC03_006/ov_SC03_006_jr_8012ACE0.c
@@ -1126,156 +1126,136 @@ extern s16 D_8018CA78[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018C9F0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018CA50;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018C9F0 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018CA58; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018CA50;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018CA58 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018CA78; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018CA78 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018C9C0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018C9C0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2309,15 +2289,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018CB74);
     u16 *pB = (*(u16 * *)&D_8018CB70);
     u16 *pC = (*(u16 * *)&D_8018CB7C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2328,15 +2308,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2349,10 +2329,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2780,57 +2760,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801F60C0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801F60C0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801F60C0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2941,26 +2916,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018CB78;
     extern u16 D_801F60C0;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018CB74 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018CB70 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018CB7C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018CB74;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018CB70; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018CB7C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018CB70; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018CB7C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801F60B0;
+    a1v = pac[0]; a2v = pac[2];
     D_801F60C0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801F60B0)) {
     found:
         pb4 = (*(u16 * *)&D_8018CB78);
         ((u16 *)p2)[0] = pb4[0];
@@ -3006,23 +2980,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018CB70;
     extern u8 D_8018CB74;
     extern u8 D_8018CB7C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018CB74);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018CB70); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018CB7C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018CB70); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018CB7C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801F60B0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801F60C0 = 0;
+    ((H16 *)&D_801F60C0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018CB78);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_006/ov_SC03_006_jr_8015C32C.c b/src/ov_SC03_006/ov_SC03_006_jr_8015C32C.c
index 3b99080f51..b22029d705 100644
--- a/src/ov_SC03_006/ov_SC03_006_jr_8015C32C.c
+++ b/src/ov_SC03_006/ov_SC03_006_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018EC7C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018EC7C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_007/ov_SC03_007_after.c b/src/ov_SC03_007/ov_SC03_007_after.c
index 4df2a33c44..cf9959a642 100644
--- a/src/ov_SC03_007/ov_SC03_007_after.c
+++ b/src/ov_SC03_007/ov_SC03_007_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80188ED0[];
+    extern s32 (*D_80188ED0[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80188ED0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80188ED0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.c b/src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.c
index 420ac3c5ad..5932028c39 100644
--- a/src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.c
+++ b/src/ov_SC03_007/ov_SC03_007_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80187870[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801877E8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80187848;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801877E8 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187850; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80187848;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80187850 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187870; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80187870 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801877B8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801877B8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018796C);
     u16 *pB = (*(u16 * *)&D_80187968);
     u16 *pC = (*(u16 * *)&D_80187974);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801E8A18;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801E8A18 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801E8A18 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80187970;
     extern u16 D_801E8A18;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018796C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80187968 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80187974 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018796C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80187968; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80187974); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80187968; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80187974); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801E8A08;
+    a1v = pac[0]; a2v = pac[2];
     D_801E8A18 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801E8A08)) {
     found:
         pb4 = (*(u16 * *)&D_80187970);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80187968;
     extern u8 D_8018796C;
     extern u8 D_80187974;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018796C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80187968); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80187974); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80187968); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80187974); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801E8A08;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801E8A18 = 0;
+    ((H16 *)&D_801E8A18)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80187970);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_007/ov_SC03_007_jr_8015C32C.c b/src/ov_SC03_007/ov_SC03_007_jr_8015C32C.c
index 7d2d324715..39d8e93c70 100644
--- a/src/ov_SC03_007/ov_SC03_007_jr_8015C32C.c
+++ b/src/ov_SC03_007/ov_SC03_007_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80189A74[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80189A74[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_010/ov_SC03_010_after.c b/src/ov_SC03_010/ov_SC03_010_after.c
index 5b0b5462ee..16a255025c 100644
--- a/src/ov_SC03_010/ov_SC03_010_after.c
+++ b/src/ov_SC03_010/ov_SC03_010_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801819F0[];
+    extern s32 (*D_801819F0[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801819F0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801819F0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.c b/src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.c
index 6bc898709d..6faccdb0cd 100644
--- a/src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.c
+++ b/src/ov_SC03_010/ov_SC03_010_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80180390[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180308; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80180368;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80180308 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180370; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80180368;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80180370 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180390; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80180390 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801802D8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801802D8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018048C);
     u16 *pB = (*(u16 * *)&D_80180488);
     u16 *pC = (*(u16 * *)&D_80180494);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019EC78;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019EC78 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019EC78 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80180490;
     extern u16 D_8019EC78;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018048C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80180488 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80180494 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018048C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80180488; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180494); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80180488; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180494); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019EC68;
+    a1v = pac[0]; a2v = pac[2];
     D_8019EC78 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019EC68)) {
     found:
         pb4 = (*(u16 * *)&D_80180490);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80180488;
     extern u8 D_8018048C;
     extern u8 D_80180494;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018048C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80180488); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80180494); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80180488); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80180494); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019EC68;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_8019EC78 = 0;
+    ((H16 *)&D_8019EC78)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80180490);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_010/ov_SC03_010_jr_8015C32C.c b/src/ov_SC03_010/ov_SC03_010_jr_8015C32C.c
index adf2abb900..f1deae12e7 100644
--- a/src/ov_SC03_010/ov_SC03_010_jr_8015C32C.c
+++ b/src/ov_SC03_010/ov_SC03_010_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80182594[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80182594[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_011/ov_SC03_011_after.c b/src/ov_SC03_011/ov_SC03_011_after.c
index 9b9c50d1a2..5bee6d7a55 100644
--- a/src/ov_SC03_011/ov_SC03_011_after.c
+++ b/src/ov_SC03_011/ov_SC03_011_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80182D60[];
+    extern s32 (*D_80182D60[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80182D60[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80182D60[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.c b/src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.c
index a7d45c789b..62818aaab1 100644
--- a/src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.c
+++ b/src/ov_SC03_011/ov_SC03_011_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80181700[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181678; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801816D8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80181678 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801816E0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801816D8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801816E0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181700; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80181700 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80181648;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80181648;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801817FC);
     u16 *pB = (*(u16 * *)&D_801817F8);
     u16 *pC = (*(u16 * *)&D_80181804);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A0F10;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A0F10 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A0F10 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80181800;
     extern u16 D_801A0F10;
 
-    register s16 *pb0 __asm__("$9");   /* D_801817FC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801817F8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80181804 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801817FC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801817F8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181804); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801817F8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181804); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A0F00;
+    a1v = pac[0]; a2v = pac[2];
     D_801A0F10 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A0F00)) {
     found:
         pb4 = (*(u16 * *)&D_80181800);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801817F8;
     extern u8 D_801817FC;
     extern u8 D_80181804;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801817FC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801817F8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80181804); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801817F8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80181804); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A0F00;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801A0F10 = 0;
+    ((H16 *)&D_801A0F10)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80181800);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_011/ov_SC03_011_jr_8015C32C.c b/src/ov_SC03_011/ov_SC03_011_jr_8015C32C.c
index 26ac5c67dd..2e3ed79e29 100644
--- a/src/ov_SC03_011/ov_SC03_011_jr_8015C32C.c
+++ b/src/ov_SC03_011/ov_SC03_011_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80183904[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80183904[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_012/ov_SC03_012_after.c b/src/ov_SC03_012/ov_SC03_012_after.c
index 599712678c..a18c57b510 100644
--- a/src/ov_SC03_012/ov_SC03_012_after.c
+++ b/src/ov_SC03_012/ov_SC03_012_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8017FC40[];
+    extern s32 (*D_8017FC40[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8017FC40[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8017FC40[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.c b/src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.c
index 654ce14651..dcd8b5de78 100644
--- a/src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.c
+++ b/src/ov_SC03_012/ov_SC03_012_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017E5E0[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E558; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017E5B8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017E558 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E5C0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017E5B8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017E5C0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E5E0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017E5E0 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017E528;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017E528;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017E6DC);
     u16 *pB = (*(u16 * *)&D_8017E6D8);
     u16 *pC = (*(u16 * *)&D_8017E6E4);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_80193D30;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_80193D30 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_80193D30 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017E6E0;
     extern u16 D_80193D30;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017E6DC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017E6D8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017E6E4 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017E6DC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017E6D8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E6E4); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017E6D8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E6E4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80193D20;
+    a1v = pac[0]; a2v = pac[2];
     D_80193D30 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80193D20)) {
     found:
         pb4 = (*(u16 * *)&D_8017E6E0);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017E6D8;
     extern u8 D_8017E6DC;
     extern u8 D_8017E6E4;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017E6DC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017E6D8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E6E4); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017E6D8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E6E4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80193D20;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_80193D30 = 0;
+    ((H16 *)&D_80193D30)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017E6E0);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_012/ov_SC03_012_jr_8015C32C.c b/src/ov_SC03_012/ov_SC03_012_jr_8015C32C.c
index c6a196bb9e..0e63793ac4 100644
--- a/src/ov_SC03_012/ov_SC03_012_jr_8015C32C.c
+++ b/src/ov_SC03_012/ov_SC03_012_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801807E4[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801807E4[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_013/ov_SC03_013_after.c b/src/ov_SC03_013/ov_SC03_013_after.c
index 394c61d76d..06cedc3cb6 100644
--- a/src/ov_SC03_013/ov_SC03_013_after.c
+++ b/src/ov_SC03_013/ov_SC03_013_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80182A28[];
+    extern s32 (*D_80182A28[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80182A28[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80182A28[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.c b/src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.c
index a941152455..a80412468f 100644
--- a/src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.c
+++ b/src/ov_SC03_013/ov_SC03_013_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801813C8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181340; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801813A0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80181340 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801813A8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801813A0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801813A8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801813C8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801813C8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80181310;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80181310;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801814C4);
     u16 *pB = (*(u16 * *)&D_801814C0);
     u16 *pC = (*(u16 * *)&D_801814CC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801AC000;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801AC000 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801AC000 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801814C8;
     extern u16 D_801AC000;
 
-    register s16 *pb0 __asm__("$9");   /* D_801814C4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801814C0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801814CC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801814C4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801814C0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801814CC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801814C0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801814CC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801ABFF0;
+    a1v = pac[0]; a2v = pac[2];
     D_801AC000 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801ABFF0)) {
     found:
         pb4 = (*(u16 * *)&D_801814C8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801814C0;
     extern u8 D_801814C4;
     extern u8 D_801814CC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801814C4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801814C0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801814CC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801814C0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801814CC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801ABFF0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801AC000 = 0;
+    ((H16 *)&D_801AC000)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801814C8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_013/ov_SC03_013_jr_8015C32C.c b/src/ov_SC03_013/ov_SC03_013_jr_8015C32C.c
index 41e9fbf688..3a700f6142 100644
--- a/src/ov_SC03_013/ov_SC03_013_jr_8015C32C.c
+++ b/src/ov_SC03_013/ov_SC03_013_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801835CC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801835CC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_014/ov_SC03_014_after.c b/src/ov_SC03_014/ov_SC03_014_after.c
index 0407322571..5530e38755 100644
--- a/src/ov_SC03_014/ov_SC03_014_after.c
+++ b/src/ov_SC03_014/ov_SC03_014_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018D064[];
+    extern s32 (*D_8018D064[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018D064[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018D064[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.c b/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.c
index d70f94c85c..1d7c649e66 100644
--- a/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.c
+++ b/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.c
@@ -1122,156 +1122,136 @@ extern s16 D_8018BA04[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B97C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018B9DC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018B97C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B9E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018B9DC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018B9E4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BA04; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018BA04 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018B94C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018B94C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2305,15 +2285,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018BB00);
     u16 *pB = (*(u16 * *)&D_8018BAFC);
     u16 *pC = (*(u16 * *)&D_8018BB08);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2324,15 +2304,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2345,10 +2325,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2776,57 +2756,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801E9580;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801E9580 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801E9580 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2937,26 +2912,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018BB04;
     extern u16 D_801E9580;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018BB00 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018BAFC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018BB08 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018BB00;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018BAFC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018BB08); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018BAFC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018BB08); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801E9570;
+    a1v = pac[0]; a2v = pac[2];
     D_801E9580 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801E9570)) {
     found:
         pb4 = (*(u16 * *)&D_8018BB04);
         ((u16 *)p2)[0] = pb4[0];
@@ -3002,23 +2976,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018BAFC;
     extern u8 D_8018BB00;
     extern u8 D_8018BB08;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018BB00);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018BAFC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018BB08); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018BAFC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018BB08); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801E9570;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801E9580 = 0;
+    ((H16 *)&D_801E9580)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018BB04);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.c b/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.c
index 0bd5e27302..7a26cf4317 100644
--- a/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.c
+++ b/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018DC08[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018DC08[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_023/ov_SC03_023_after.c b/src/ov_SC03_023/ov_SC03_023_after.c
index 0ff2287a6c..d15d33a1f8 100644
--- a/src/ov_SC03_023/ov_SC03_023_after.c
+++ b/src/ov_SC03_023/ov_SC03_023_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801809E0[];
+    extern s32 (*D_801809E0[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801809E0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801809E0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.c b/src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.c
index 677609fd2a..b7cd7ff680 100644
--- a/src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.c
+++ b/src/ov_SC03_023/ov_SC03_023_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017F380[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F2F8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017F358;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017F2F8 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F360; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017F358;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017F360 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F380; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017F380 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017F2C8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017F2C8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017F47C);
     u16 *pB = (*(u16 * *)&D_8017F478);
     u16 *pC = (*(u16 * *)&D_8017F484);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_80197958;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_80197958 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_80197958 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017F480;
     extern u16 D_80197958;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017F47C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017F478 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017F484 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017F47C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017F478; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F484); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017F478; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F484); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80197948;
+    a1v = pac[0]; a2v = pac[2];
     D_80197958 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80197948)) {
     found:
         pb4 = (*(u16 * *)&D_8017F480);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017F478;
     extern u8 D_8017F47C;
     extern u8 D_8017F484;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017F47C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017F478); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F484); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017F478); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F484); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80197948;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_80197958 = 0;
+    ((H16 *)&D_80197958)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017F480);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_023/ov_SC03_023_jr_8015C32C.c b/src/ov_SC03_023/ov_SC03_023_jr_8015C32C.c
index 5ef9c9cdfe..d7f88ed9cb 100644
--- a/src/ov_SC03_023/ov_SC03_023_jr_8015C32C.c
+++ b/src/ov_SC03_023/ov_SC03_023_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80181584[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80181584[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_024/ov_SC03_024_after.c b/src/ov_SC03_024/ov_SC03_024_after.c
index ee55d1820d..3a4445fc9a 100644
--- a/src/ov_SC03_024/ov_SC03_024_after.c
+++ b/src/ov_SC03_024/ov_SC03_024_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80188A04[];
+    extern s32 (*D_80188A04[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80188A04[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80188A04[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.c b/src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.c
index d49ec86be7..461db332fc 100644
--- a/src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.c
+++ b/src/ov_SC03_024/ov_SC03_024_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801873A4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018731C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018737C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018731C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187384; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018737C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80187384 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801873A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801873A4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801872EC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801872EC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801874A0);
     u16 *pB = (*(u16 * *)&D_8018749C);
     u16 *pC = (*(u16 * *)&D_801874A8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801BFEF0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801BFEF0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801BFEF0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801874A4;
     extern u16 D_801BFEF0;
 
-    register s16 *pb0 __asm__("$9");   /* D_801874A0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018749C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801874A8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801874A0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018749C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801874A8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018749C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801874A8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801BFEE0;
+    a1v = pac[0]; a2v = pac[2];
     D_801BFEF0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801BFEE0)) {
     found:
         pb4 = (*(u16 * *)&D_801874A4);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018749C;
     extern u8 D_801874A0;
     extern u8 D_801874A8;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801874A0);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018749C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801874A8); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018749C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801874A8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801BFEE0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801BFEF0 = 0;
+    ((H16 *)&D_801BFEF0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801874A4);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_024/ov_SC03_024_jr_8015C32C.c b/src/ov_SC03_024/ov_SC03_024_jr_8015C32C.c
index f7d1b7ba98..c53c78b6f5 100644
--- a/src/ov_SC03_024/ov_SC03_024_jr_8015C32C.c
+++ b/src/ov_SC03_024/ov_SC03_024_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801895A8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801895A8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_028/ov_SC03_028_after.c b/src/ov_SC03_028/ov_SC03_028_after.c
index c4e92eb566..268670746a 100644
--- a/src/ov_SC03_028/ov_SC03_028_after.c
+++ b/src/ov_SC03_028/ov_SC03_028_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018D4D0[];
+    extern s32 (*D_8018D4D0[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018D4D0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018D4D0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.c b/src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.c
index f813a54811..f0e377aa22 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018BE70[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BDE8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018BE48;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018BDE8 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BE50; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018BE48;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018BE50 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BE70; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018BE70 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018BDB8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018BDB8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018BF6C);
     u16 *pB = (*(u16 * *)&D_8018BF68);
     u16 *pC = (*(u16 * *)&D_8018BF74);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801EA228;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801EA228 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801EA228 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018BF70;
     extern u16 D_801EA228;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018BF6C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018BF68 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018BF74 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018BF6C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018BF68; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018BF74); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018BF68; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018BF74); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801EA218;
+    a1v = pac[0]; a2v = pac[2];
     D_801EA228 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801EA218)) {
     found:
         pb4 = (*(u16 * *)&D_8018BF70);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018BF68;
     extern u8 D_8018BF6C;
     extern u8 D_8018BF74;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018BF6C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018BF68); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018BF74); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018BF68); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018BF74); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801EA218;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801EA228 = 0;
+    ((H16 *)&D_801EA228)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018BF70);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_028/ov_SC03_028_jr_8015C32C.c b/src/ov_SC03_028/ov_SC03_028_jr_8015C32C.c
index b47f885931..05ff5810d8 100644
--- a/src/ov_SC03_028/ov_SC03_028_jr_8015C32C.c
+++ b/src/ov_SC03_028/ov_SC03_028_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018E074[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018E074[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_029/ov_SC03_029_after.c b/src/ov_SC03_029/ov_SC03_029_after.c
index 90bdbb54fe..9e256cc218 100644
--- a/src/ov_SC03_029/ov_SC03_029_after.c
+++ b/src/ov_SC03_029/ov_SC03_029_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80189308[];
+    extern s32 (*D_80189308[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80189308[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80189308[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.c b/src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.c
index 03b6dec9d7..fccb7cd08c 100644
--- a/src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.c
+++ b/src/ov_SC03_029/ov_SC03_029_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80187CA8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187C20; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80187C80;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80187C20 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187C88; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80187C80;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80187C88 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187CA8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80187CA8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80187BF0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80187BF0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80187DA4);
     u16 *pB = (*(u16 * *)&D_80187DA0);
     u16 *pC = (*(u16 * *)&D_80187DAC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus2)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus2)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus2)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801D8200;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801D8200 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801D8200 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80187DA8;
     extern u16 D_801D8200;
 
-    register s16 *pb0 __asm__("$9");   /* D_80187DA4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80187DA0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80187DAC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80187DA4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80187DA0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80187DAC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80187DA0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80187DAC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801D81F0;
+    a1v = pac[0]; a2v = pac[2];
     D_801D8200 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801D81F0)) {
     found:
         pb4 = (*(u16 * *)&D_80187DA8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80187DA0;
     extern u8 D_80187DA4;
     extern u8 D_80187DAC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus2)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus2)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80187DA4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus2)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80187DA0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80187DAC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80187DA0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80187DAC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801D81F0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-    D_801D8200 = 0;
+    ((H16 *)&D_801D8200)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80187DA8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_029/ov_SC03_029_jr_8015C32C.c b/src/ov_SC03_029/ov_SC03_029_jr_8015C32C.c
index 5c901cce68..186163307d 100644
--- a/src/ov_SC03_029/ov_SC03_029_jr_8015C32C.c
+++ b/src/ov_SC03_029/ov_SC03_029_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80189EAC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80189EAC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_030/ov_SC03_030_after.c b/src/ov_SC03_030/ov_SC03_030_after.c
index 8e68cc94fa..1c12251e3e 100644
--- a/src/ov_SC03_030/ov_SC03_030_after.c
+++ b/src/ov_SC03_030/ov_SC03_030_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80183944[];
+    extern s32 (*D_80183944[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80183944[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80183944[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.c b/src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.c
index 3e27609696..b52839d419 100644
--- a/src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.c
+++ b/src/ov_SC03_030/ov_SC03_030_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801822E4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018225C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801822BC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018225C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801822C4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801822BC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801822C4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801822E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801822E4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018222C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018222C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801823E0);
     u16 *pB = (*(u16 * *)&D_801823DC);
     u16 *pC = (*(u16 * *)&D_801823E8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801E07F8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801E07F8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801E07F8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801823E4;
     extern u16 D_801E07F8;
 
-    register s16 *pb0 __asm__("$9");   /* D_801823E0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801823DC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801823E8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801823E0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801823DC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801823E8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801823DC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801823E8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801E07E8;
+    a1v = pac[0]; a2v = pac[2];
     D_801E07F8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801E07E8)) {
     found:
         pb4 = (*(u16 * *)&D_801823E4);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801823DC;
     extern u8 D_801823E0;
     extern u8 D_801823E8;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801823E0);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801823DC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801823E8); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801823DC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801823E8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801E07E8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801E07F8 = 0;
+    ((H16 *)&D_801E07F8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801823E4);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_030/ov_SC03_030_jr_8015C32C.c b/src/ov_SC03_030/ov_SC03_030_jr_8015C32C.c
index d2b08dacb4..09b5bc8735 100644
--- a/src/ov_SC03_030/ov_SC03_030_jr_8015C32C.c
+++ b/src/ov_SC03_030/ov_SC03_030_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801844E8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801844E8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_031/ov_SC03_031_after.c b/src/ov_SC03_031/ov_SC03_031_after.c
index 07c6f0ec89..2ef83f587e 100644
--- a/src/ov_SC03_031/ov_SC03_031_after.c
+++ b/src/ov_SC03_031/ov_SC03_031_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80183E60[];
+    extern s32 (*D_80183E60[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80183E60[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80183E60[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.c b/src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.c
index 662c954fdf..7e4926b291 100644
--- a/src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.c
+++ b/src/ov_SC03_031/ov_SC03_031_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80182800[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182778; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801827D8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80182778 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801827E0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801827D8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801827E0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182800; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80182800 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80182748;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80182748;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801828FC);
     u16 *pB = (*(u16 * *)&D_801828F8);
     u16 *pC = (*(u16 * *)&D_80182904);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C4BF8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C4BF8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C4BF8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80182900;
     extern u16 D_801C4BF8;
 
-    register s16 *pb0 __asm__("$9");   /* D_801828FC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801828F8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80182904 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801828FC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801828F8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182904); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801828F8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182904); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801C4BE8;
+    a1v = pac[0]; a2v = pac[2];
     D_801C4BF8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801C4BE8)) {
     found:
         pb4 = (*(u16 * *)&D_80182900);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801828F8;
     extern u8 D_801828FC;
     extern u8 D_80182904;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801828FC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801828F8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182904); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801828F8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182904); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801C4BE8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801C4BF8 = 0;
+    ((H16 *)&D_801C4BF8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80182900);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_031/ov_SC03_031_jr_8015C32C.c b/src/ov_SC03_031/ov_SC03_031_jr_8015C32C.c
index e11296bab7..e9a61510cf 100644
--- a/src/ov_SC03_031/ov_SC03_031_jr_8015C32C.c
+++ b/src/ov_SC03_031/ov_SC03_031_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80184A04[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80184A04[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_089/ov_SC03_089_after.c b/src/ov_SC03_089/ov_SC03_089_after.c
index 3d3ded90c6..457d5949d3 100644
--- a/src/ov_SC03_089/ov_SC03_089_after.c
+++ b/src/ov_SC03_089/ov_SC03_089_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018B15C[];
+    extern s32 (*D_8018B15C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018B15C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018B15C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.c b/src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.c
index 30269be0da..ad142d567b 100644
--- a/src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.c
+++ b/src/ov_SC03_089/ov_SC03_089_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80189AFC[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80189A74; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80189AD4;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80189A74 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80189ADC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80189AD4;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80189ADC + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80189AFC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80189AFC + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80189A44;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80189A44;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80189BF8);
     u16 *pB = (*(u16 * *)&D_80189BF4);
     u16 *pC = (*(u16 * *)&D_80189C00);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C54B0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C54B0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C54B0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80189BFC;
     extern u16 D_801C54B0;
 
-    register s16 *pb0 __asm__("$9");   /* D_80189BF8 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80189BF4 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80189C00 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80189BF8;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80189BF4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80189C00); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80189BF4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80189C00); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801C54A0;
+    a1v = pac[0]; a2v = pac[2];
     D_801C54B0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801C54A0)) {
     found:
         pb4 = (*(u16 * *)&D_80189BFC);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80189BF4;
     extern u8 D_80189BF8;
     extern u8 D_80189C00;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80189BF8);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80189BF4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80189C00); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80189BF4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80189C00); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801C54A0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801C54B0 = 0;
+    ((H16 *)&D_801C54B0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80189BFC);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_089/ov_SC03_089_jr_8015C32C.c b/src/ov_SC03_089/ov_SC03_089_jr_8015C32C.c
index 68ca7685f3..1e035e7a14 100644
--- a/src/ov_SC03_089/ov_SC03_089_jr_8015C32C.c
+++ b/src/ov_SC03_089/ov_SC03_089_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018BD00[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018BD00[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_090/ov_SC03_090_after.c b/src/ov_SC03_090/ov_SC03_090_after.c
index 326b45b672..7858d91244 100644
--- a/src/ov_SC03_090/ov_SC03_090_after.c
+++ b/src/ov_SC03_090/ov_SC03_090_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018D580[];
+    extern s32 (*D_8018D580[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018D580[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018D580[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.c b/src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.c
index 237184f48a..b21ccccb8a 100644
--- a/src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.c
+++ b/src/ov_SC03_090/ov_SC03_090_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018BF20[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BE98; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018BEF8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018BE98 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BF00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018BEF8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018BF00 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018BF20; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018BF20 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018BE68;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018BE68;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018C01C);
     u16 *pB = (*(u16 * *)&D_8018C018);
     u16 *pC = (*(u16 * *)&D_8018C024);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801CA918;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801CA918 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801CA918 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018C020;
     extern u16 D_801CA918;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018C01C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018C018 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018C024 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018C01C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018C018; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018C024); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018C018; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018C024); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801CA908;
+    a1v = pac[0]; a2v = pac[2];
     D_801CA918 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801CA908)) {
     found:
         pb4 = (*(u16 * *)&D_8018C020);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018C018;
     extern u8 D_8018C01C;
     extern u8 D_8018C024;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018C01C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018C018); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018C024); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018C018); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018C024); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801CA908;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801CA918 = 0;
+    ((H16 *)&D_801CA918)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018C020);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_090/ov_SC03_090_jr_8015C32C.c b/src/ov_SC03_090/ov_SC03_090_jr_8015C32C.c
index aab626b0fc..3551c481b3 100644
--- a/src/ov_SC03_090/ov_SC03_090_jr_8015C32C.c
+++ b/src/ov_SC03_090/ov_SC03_090_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018E124[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018E124[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_091/ov_SC03_091_after.c b/src/ov_SC03_091/ov_SC03_091_after.c
index 104db71362..adde499400 100644
--- a/src/ov_SC03_091/ov_SC03_091_after.c
+++ b/src/ov_SC03_091/ov_SC03_091_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018E428[];
+    extern s32 (*D_8018E428[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018E428[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018E428[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.c b/src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.c
index 04793c1ddb..fdcc26e209 100644
--- a/src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.c
+++ b/src/ov_SC03_091/ov_SC03_091_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018CDC8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018CD40; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018CDA0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018CD40 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018CDA8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018CDA0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018CDA8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018CDC8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018CDC8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018CD10;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018CD10;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018CEC4);
     u16 *pB = (*(u16 * *)&D_8018CEC0);
     u16 *pC = (*(u16 * *)&D_8018CECC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801D0FE8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801D0FE8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801D0FE8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018CEC8;
     extern u16 D_801D0FE8;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018CEC4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018CEC0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018CECC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018CEC4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018CEC0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018CECC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018CEC0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018CECC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801D0FD8;
+    a1v = pac[0]; a2v = pac[2];
     D_801D0FE8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801D0FD8)) {
     found:
         pb4 = (*(u16 * *)&D_8018CEC8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018CEC0;
     extern u8 D_8018CEC4;
     extern u8 D_8018CECC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018CEC4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018CEC0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018CECC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018CEC0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018CECC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801D0FD8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801D0FE8 = 0;
+    ((H16 *)&D_801D0FE8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018CEC8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_091/ov_SC03_091_jr_8015C32C.c b/src/ov_SC03_091/ov_SC03_091_jr_8015C32C.c
index f6cca805aa..8b099373fb 100644
--- a/src/ov_SC03_091/ov_SC03_091_jr_8015C32C.c
+++ b/src/ov_SC03_091/ov_SC03_091_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018EFCC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018EFCC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_092/ov_SC03_092_after.c b/src/ov_SC03_092/ov_SC03_092_after.c
index 58baa60562..f436f2d769 100644
--- a/src/ov_SC03_092/ov_SC03_092_after.c
+++ b/src/ov_SC03_092/ov_SC03_092_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801867F8[];
+    extern s32 (*D_801867F8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801867F8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801867F8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.c b/src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.c
index 88f2d4840d..dea16006c7 100644
--- a/src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.c
+++ b/src/ov_SC03_092/ov_SC03_092_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80185198[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185110; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80185170;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80185110 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185178; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80185170;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80185178 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185198; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80185198 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801850E0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801850E0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80185294);
     u16 *pB = (*(u16 * *)&D_80185290);
     u16 *pC = (*(u16 * *)&D_8018529C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B1BB0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B1BB0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B1BB0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80185298;
     extern u16 D_801B1BB0;
 
-    register s16 *pb0 __asm__("$9");   /* D_80185294 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80185290 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018529C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80185294;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80185290; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018529C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80185290; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018529C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B1BA0;
+    a1v = pac[0]; a2v = pac[2];
     D_801B1BB0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B1BA0)) {
     found:
         pb4 = (*(u16 * *)&D_80185298);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80185290;
     extern u8 D_80185294;
     extern u8 D_8018529C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80185294);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80185290); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018529C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80185290); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018529C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B1BA0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801B1BB0 = 0;
+    ((H16 *)&D_801B1BB0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80185298);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_092/ov_SC03_092_jr_8015C32C.c b/src/ov_SC03_092/ov_SC03_092_jr_8015C32C.c
index 21a8fdaaa0..cd6feef9d3 100644
--- a/src/ov_SC03_092/ov_SC03_092_jr_8015C32C.c
+++ b/src/ov_SC03_092/ov_SC03_092_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018739C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018739C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_093/ov_SC03_093_after.c b/src/ov_SC03_093/ov_SC03_093_after.c
index dad21237e7..50a2d8c0e6 100644
--- a/src/ov_SC03_093/ov_SC03_093_after.c
+++ b/src/ov_SC03_093/ov_SC03_093_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801879D0[];
+    extern s32 (*D_801879D0[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801879D0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801879D0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.c b/src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.c
index 285b8de5ec..105c99faf4 100644
--- a/src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.c
+++ b/src/ov_SC03_093/ov_SC03_093_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80186370[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801862E8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80186348;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801862E8 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186350; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80186348;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80186350 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186370; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80186370 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801862B8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801862B8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018646C);
     u16 *pB = (*(u16 * *)&D_80186468);
     u16 *pC = (*(u16 * *)&D_80186474);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801CB020;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801CB020 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801CB020 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80186470;
     extern u16 D_801CB020;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018646C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80186468 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80186474 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018646C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80186468; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186474); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80186468; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186474); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801CB010;
+    a1v = pac[0]; a2v = pac[2];
     D_801CB020 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801CB010)) {
     found:
         pb4 = (*(u16 * *)&D_80186470);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80186468;
     extern u8 D_8018646C;
     extern u8 D_80186474;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018646C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80186468); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186474); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80186468); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186474); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801CB010;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801CB020 = 0;
+    ((H16 *)&D_801CB020)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80186470);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_093/ov_SC03_093_jr_8015C32C.c b/src/ov_SC03_093/ov_SC03_093_jr_8015C32C.c
index cc56943b73..cd5dde735c 100644
--- a/src/ov_SC03_093/ov_SC03_093_jr_8015C32C.c
+++ b/src/ov_SC03_093/ov_SC03_093_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80188574[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80188574[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_094/ov_SC03_094_after.c b/src/ov_SC03_094/ov_SC03_094_after.c
index 8cbc07292b..898948d212 100644
--- a/src/ov_SC03_094/ov_SC03_094_after.c
+++ b/src/ov_SC03_094/ov_SC03_094_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801893CC[];
+    extern s32 (*D_801893CC[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801893CC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801893CC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.c b/src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.c
index 4d46834049..0166ce1396 100644
--- a/src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.c
+++ b/src/ov_SC03_094/ov_SC03_094_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80187D6C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187CE4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80187D44;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80187CE4 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187D4C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80187D44;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80187D4C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187D6C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80187D6C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80187CB4;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80187CB4;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80187E68);
     u16 *pB = (*(u16 * *)&D_80187E64);
     u16 *pC = (*(u16 * *)&D_80187E70);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801D1E60;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801D1E60 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801D1E60 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80187E6C;
     extern u16 D_801D1E60;
 
-    register s16 *pb0 __asm__("$9");   /* D_80187E68 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80187E64 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80187E70 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80187E68;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80187E64; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80187E70); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80187E64; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80187E70); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801D1E50;
+    a1v = pac[0]; a2v = pac[2];
     D_801D1E60 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801D1E50)) {
     found:
         pb4 = (*(u16 * *)&D_80187E6C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80187E64;
     extern u8 D_80187E68;
     extern u8 D_80187E70;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80187E68);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80187E64); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80187E70); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80187E64); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80187E70); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801D1E50;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801D1E60 = 0;
+    ((H16 *)&D_801D1E60)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80187E6C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_094/ov_SC03_094_jr_8015C32C.c b/src/ov_SC03_094/ov_SC03_094_jr_8015C32C.c
index 1c1cb33c97..1b57950747 100644
--- a/src/ov_SC03_094/ov_SC03_094_jr_8015C32C.c
+++ b/src/ov_SC03_094/ov_SC03_094_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80189F70[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80189F70[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_095/ov_SC03_095_after.c b/src/ov_SC03_095/ov_SC03_095_after.c
index d950ad6792..5598c91a4a 100644
--- a/src/ov_SC03_095/ov_SC03_095_after.c
+++ b/src/ov_SC03_095/ov_SC03_095_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80182A2C[];
+    extern s32 (*D_80182A2C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80182A2C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80182A2C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.c b/src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.c
index 044dd2b5ea..0a2d24dc6c 100644
--- a/src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.c
+++ b/src/ov_SC03_095/ov_SC03_095_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801813CC[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181344; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801813A4;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80181344 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801813AC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801813A4;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801813AC + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801813CC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801813CC + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80181314;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80181314;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801814C8);
     u16 *pB = (*(u16 * *)&D_801814C4);
     u16 *pC = (*(u16 * *)&D_801814D0);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019AA58;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019AA58 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019AA58 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801814CC;
     extern u16 D_8019AA58;
 
-    register s16 *pb0 __asm__("$9");   /* D_801814C8 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801814C4 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801814D0 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801814C8;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801814C4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801814D0); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801814C4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801814D0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019AA48;
+    a1v = pac[0]; a2v = pac[2];
     D_8019AA58 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019AA48)) {
     found:
         pb4 = (*(u16 * *)&D_801814CC);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801814C4;
     extern u8 D_801814C8;
     extern u8 D_801814D0;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801814C8);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801814C4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801814D0); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801814C4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801814D0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019AA48;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_8019AA58 = 0;
+    ((H16 *)&D_8019AA58)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801814CC);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_095/ov_SC03_095_jr_8015C32C.c b/src/ov_SC03_095/ov_SC03_095_jr_8015C32C.c
index bf4e52cf7b..94c456b6f6 100644
--- a/src/ov_SC03_095/ov_SC03_095_jr_8015C32C.c
+++ b/src/ov_SC03_095/ov_SC03_095_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801835D0[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801835D0[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_096/ov_SC03_096_after.c b/src/ov_SC03_096/ov_SC03_096_after.c
index a648b762d3..2114a502d0 100644
--- a/src/ov_SC03_096/ov_SC03_096_after.c
+++ b/src/ov_SC03_096/ov_SC03_096_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801825AC[];
+    extern s32 (*D_801825AC[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801825AC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801825AC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.c b/src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.c
index 7cb9cb1ea5..7d0dec5fc0 100644
--- a/src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.c
+++ b/src/ov_SC03_096/ov_SC03_096_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80180F4C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180EC4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80180F24;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80180EC4 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180F2C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80180F24;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80180F2C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180F4C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80180F4C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80180E94;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80180E94;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80181048);
     u16 *pB = (*(u16 * *)&D_80181044);
     u16 *pC = (*(u16 * *)&D_80181050);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_80199510;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_80199510 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_80199510 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018104C;
     extern u16 D_80199510;
 
-    register s16 *pb0 __asm__("$9");   /* D_80181048 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80181044 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80181050 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80181048;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80181044; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181050); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80181044; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181050); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80199500;
+    a1v = pac[0]; a2v = pac[2];
     D_80199510 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80199500)) {
     found:
         pb4 = (*(u16 * *)&D_8018104C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80181044;
     extern u8 D_80181048;
     extern u8 D_80181050;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80181048);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80181044); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80181050); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80181044); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80181050); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80199500;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_80199510 = 0;
+    ((H16 *)&D_80199510)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018104C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_096/ov_SC03_096_jr_8015C32C.c b/src/ov_SC03_096/ov_SC03_096_jr_8015C32C.c
index 5a01151ccd..d57740ac59 100644
--- a/src/ov_SC03_096/ov_SC03_096_jr_8015C32C.c
+++ b/src/ov_SC03_096/ov_SC03_096_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80183150[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80183150[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_097/ov_SC03_097_after.c b/src/ov_SC03_097/ov_SC03_097_after.c
index dce7dfcad8..770cb9ec22 100644
--- a/src/ov_SC03_097/ov_SC03_097_after.c
+++ b/src/ov_SC03_097/ov_SC03_097_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018798C[];
+    extern s32 (*D_8018798C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018798C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018798C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.c b/src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.c
index 8462795460..474cb4241d 100644
--- a/src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.c
+++ b/src/ov_SC03_097/ov_SC03_097_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018632C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801862A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80186304;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801862A4 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018630C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80186304;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018630C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018632C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018632C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80186274;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80186274;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80186428);
     u16 *pB = (*(u16 * *)&D_80186424);
     u16 *pC = (*(u16 * *)&D_80186430);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A9598;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A9598 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A9598 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018642C;
     extern u16 D_801A9598;
 
-    register s16 *pb0 __asm__("$9");   /* D_80186428 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80186424 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80186430 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80186428;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80186424; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186430); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80186424; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186430); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A9588;
+    a1v = pac[0]; a2v = pac[2];
     D_801A9598 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A9588)) {
     found:
         pb4 = (*(u16 * *)&D_8018642C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80186424;
     extern u8 D_80186428;
     extern u8 D_80186430;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80186428);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80186424); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186430); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80186424); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186430); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A9588;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801A9598 = 0;
+    ((H16 *)&D_801A9598)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018642C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_097/ov_SC03_097_jr_8015C32C.c b/src/ov_SC03_097/ov_SC03_097_jr_8015C32C.c
index 0d0458704b..abba8b74e1 100644
--- a/src/ov_SC03_097/ov_SC03_097_jr_8015C32C.c
+++ b/src/ov_SC03_097/ov_SC03_097_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80188530[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80188530[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_098/ov_SC03_098_after.c b/src/ov_SC03_098/ov_SC03_098_after.c
index 5a04271d5b..b0ff6a6470 100644
--- a/src/ov_SC03_098/ov_SC03_098_after.c
+++ b/src/ov_SC03_098/ov_SC03_098_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80186E18[];
+    extern s32 (*D_80186E18[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80186E18[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80186E18[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.c b/src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.c
index 1a0faaf4ca..88e18a5b54 100644
--- a/src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.c
+++ b/src/ov_SC03_098/ov_SC03_098_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801857B8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185730; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80185790;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80185730 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185798; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80185790;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80185798 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801857B8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801857B8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80185700;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80185700;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801858B4);
     u16 *pB = (*(u16 * *)&D_801858B0);
     u16 *pC = (*(u16 * *)&D_801858BC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C4208;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C4208 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C4208 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801858B8;
     extern u16 D_801C4208;
 
-    register s16 *pb0 __asm__("$9");   /* D_801858B4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801858B0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801858BC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801858B4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801858B0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801858BC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801858B0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801858BC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801C41F8;
+    a1v = pac[0]; a2v = pac[2];
     D_801C4208 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801C41F8)) {
     found:
         pb4 = (*(u16 * *)&D_801858B8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801858B0;
     extern u8 D_801858B4;
     extern u8 D_801858BC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801858B4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801858B0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801858BC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801858B0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801858BC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801C41F8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801C4208 = 0;
+    ((H16 *)&D_801C4208)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801858B8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_098/ov_SC03_098_jr_8015C32C.c b/src/ov_SC03_098/ov_SC03_098_jr_8015C32C.c
index 2d27cdeab5..31dd9329b2 100644
--- a/src/ov_SC03_098/ov_SC03_098_jr_8015C32C.c
+++ b/src/ov_SC03_098/ov_SC03_098_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801879BC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801879BC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_099/ov_SC03_099_after.c b/src/ov_SC03_099/ov_SC03_099_after.c
index 61664e8375..705a00cc91 100644
--- a/src/ov_SC03_099/ov_SC03_099_after.c
+++ b/src/ov_SC03_099/ov_SC03_099_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80184F18[];
+    extern s32 (*D_80184F18[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80184F18[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80184F18[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.c b/src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.c
index cbf86308cd..a435e03cee 100644
--- a/src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.c
+++ b/src/ov_SC03_099/ov_SC03_099_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801838B8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183830; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80183890;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80183830 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183898; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80183890;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80183898 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801838B8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801838B8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80183800;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80183800;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801839B4);
     u16 *pB = (*(u16 * *)&D_801839B0);
     u16 *pC = (*(u16 * *)&D_801839BC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801BDED8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801BDED8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801BDED8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801839B8;
     extern u16 D_801BDED8;
 
-    register s16 *pb0 __asm__("$9");   /* D_801839B4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801839B0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801839BC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801839B4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801839B0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801839BC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801839B0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801839BC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801BDEC8;
+    a1v = pac[0]; a2v = pac[2];
     D_801BDED8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801BDEC8)) {
     found:
         pb4 = (*(u16 * *)&D_801839B8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801839B0;
     extern u8 D_801839B4;
     extern u8 D_801839BC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801839B4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801839B0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801839BC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801839B0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801839BC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801BDEC8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801BDED8 = 0;
+    ((H16 *)&D_801BDED8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801839B8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_099/ov_SC03_099_jr_8015C32C.c b/src/ov_SC03_099/ov_SC03_099_jr_8015C32C.c
index f88ee6826e..499b262666 100644
--- a/src/ov_SC03_099/ov_SC03_099_jr_8015C32C.c
+++ b/src/ov_SC03_099/ov_SC03_099_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80185ABC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80185ABC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_100/ov_SC03_100_after.c b/src/ov_SC03_100/ov_SC03_100_after.c
index f2ee52b2a8..0a3b208678 100644
--- a/src/ov_SC03_100/ov_SC03_100_after.c
+++ b/src/ov_SC03_100/ov_SC03_100_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801863E4[];
+    extern s32 (*D_801863E4[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801863E4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801863E4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.c b/src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.c
index 5a76a06cbc..858362fc46 100644
--- a/src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.c
+++ b/src/ov_SC03_100/ov_SC03_100_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80184D84[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184CFC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80184D5C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80184CFC + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184D64; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80184D5C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80184D64 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184D84; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80184D84 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80184CCC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80184CCC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80184E80);
     u16 *pB = (*(u16 * *)&D_80184E7C);
     u16 *pC = (*(u16 * *)&D_80184E88);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C7160;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C7160 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C7160 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80184E84;
     extern u16 D_801C7160;
 
-    register s16 *pb0 __asm__("$9");   /* D_80184E80 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80184E7C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80184E88 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80184E80;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80184E7C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184E88); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80184E7C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184E88); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801C7150;
+    a1v = pac[0]; a2v = pac[2];
     D_801C7160 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801C7150)) {
     found:
         pb4 = (*(u16 * *)&D_80184E84);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80184E7C;
     extern u8 D_80184E80;
     extern u8 D_80184E88;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80184E80);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80184E7C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184E88); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80184E7C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184E88); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801C7150;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801C7160 = 0;
+    ((H16 *)&D_801C7160)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80184E84);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_100/ov_SC03_100_jr_8015C32C.c b/src/ov_SC03_100/ov_SC03_100_jr_8015C32C.c
index f10a1565f8..ab8bcbb096 100644
--- a/src/ov_SC03_100/ov_SC03_100_jr_8015C32C.c
+++ b/src/ov_SC03_100/ov_SC03_100_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80186F88[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80186F88[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_101/ov_SC03_101_after.c b/src/ov_SC03_101/ov_SC03_101_after.c
index 2184c9fa73..15cac6a7b3 100644
--- a/src/ov_SC03_101/ov_SC03_101_after.c
+++ b/src/ov_SC03_101/ov_SC03_101_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801853C0[];
+    extern s32 (*D_801853C0[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801853C0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801853C0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.c b/src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.c
index 03f1b1952d..61b58fdd7b 100644
--- a/src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.c
+++ b/src/ov_SC03_101/ov_SC03_101_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80183D60[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183CD8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80183D38;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80183CD8 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183D40; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80183D38;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80183D40 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183D60; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80183D60 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80183CA8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80183CA8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80183E5C);
     u16 *pB = (*(u16 * *)&D_80183E58);
     u16 *pC = (*(u16 * *)&D_80183E64);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019CA28;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019CA28 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019CA28 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80183E60;
     extern u16 D_8019CA28;
 
-    register s16 *pb0 __asm__("$9");   /* D_80183E5C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80183E58 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80183E64 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80183E5C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80183E58; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183E64); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80183E58; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183E64); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019CA18;
+    a1v = pac[0]; a2v = pac[2];
     D_8019CA28 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019CA18)) {
     found:
         pb4 = (*(u16 * *)&D_80183E60);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80183E58;
     extern u8 D_80183E5C;
     extern u8 D_80183E64;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80183E5C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80183E58); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80183E64); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80183E58); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80183E64); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019CA18;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_8019CA28 = 0;
+    ((H16 *)&D_8019CA28)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80183E60);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_101/ov_SC03_101_jr_8015C32C.c b/src/ov_SC03_101/ov_SC03_101_jr_8015C32C.c
index 87a9306a2a..37d67bf9e7 100644
--- a/src/ov_SC03_101/ov_SC03_101_jr_8015C32C.c
+++ b/src/ov_SC03_101/ov_SC03_101_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80185F64[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80185F64[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_102/ov_SC03_102_after.c b/src/ov_SC03_102/ov_SC03_102_after.c
index f802a9a9be..88e5377341 100644
--- a/src/ov_SC03_102/ov_SC03_102_after.c
+++ b/src/ov_SC03_102/ov_SC03_102_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80187C78[];
+    extern s32 (*D_80187C78[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80187C78[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80187C78[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.c b/src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.c
index 88d375c6ef..300e18afa3 100644
--- a/src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.c
+++ b/src/ov_SC03_102/ov_SC03_102_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80186618[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186590; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801865F0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80186590 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801865F8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801865F0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801865F8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186618; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80186618 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80186560;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80186560;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80186714);
     u16 *pB = (*(u16 * *)&D_80186710);
     u16 *pC = (*(u16 * *)&D_8018671C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B86A0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B86A0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B86A0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80186718;
     extern u16 D_801B86A0;
 
-    register s16 *pb0 __asm__("$9");   /* D_80186714 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80186710 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018671C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80186714;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80186710; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018671C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80186710; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018671C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8690;
+    a1v = pac[0]; a2v = pac[2];
     D_801B86A0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B8690)) {
     found:
         pb4 = (*(u16 * *)&D_80186718);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80186710;
     extern u8 D_80186714;
     extern u8 D_8018671C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80186714);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80186710); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018671C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80186710); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018671C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B8690;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801B86A0 = 0;
+    ((H16 *)&D_801B86A0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80186718);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_102/ov_SC03_102_jr_8015C32C.c b/src/ov_SC03_102/ov_SC03_102_jr_8015C32C.c
index cc8085a8cd..26fd5337b9 100644
--- a/src/ov_SC03_102/ov_SC03_102_jr_8015C32C.c
+++ b/src/ov_SC03_102/ov_SC03_102_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018881C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018881C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_103/ov_SC03_103_after.c b/src/ov_SC03_103/ov_SC03_103_after.c
index cab441338e..302180c7b1 100644
--- a/src/ov_SC03_103/ov_SC03_103_after.c
+++ b/src/ov_SC03_103/ov_SC03_103_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80185C28[];
+    extern s32 (*D_80185C28[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80185C28[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80185C28[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.c b/src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.c
index 6b8855f23d..eff1a5e1aa 100644
--- a/src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.c
+++ b/src/ov_SC03_103/ov_SC03_103_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801845C8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184540; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801845A0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80184540 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801845A8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801845A0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801845A8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801845C8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801845C8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80184510;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80184510;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801846C4);
     u16 *pB = (*(u16 * *)&D_801846C0);
     u16 *pC = (*(u16 * *)&D_801846CC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C3858;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C3858 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C3858 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801846C8;
     extern u16 D_801C3858;
 
-    register s16 *pb0 __asm__("$9");   /* D_801846C4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801846C0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801846CC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801846C4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801846C0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801846CC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801846C0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801846CC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801C3848;
+    a1v = pac[0]; a2v = pac[2];
     D_801C3858 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801C3848)) {
     found:
         pb4 = (*(u16 * *)&D_801846C8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801846C0;
     extern u8 D_801846C4;
     extern u8 D_801846CC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801846C4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801846C0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801846CC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801846C0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801846CC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801C3848;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801C3858 = 0;
+    ((H16 *)&D_801C3858)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801846C8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_103/ov_SC03_103_jr_8015C32C.c b/src/ov_SC03_103/ov_SC03_103_jr_8015C32C.c
index 0828e97407..cb8fdc58a6 100644
--- a/src/ov_SC03_103/ov_SC03_103_jr_8015C32C.c
+++ b/src/ov_SC03_103/ov_SC03_103_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801867CC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801867CC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_104/ov_SC03_104_after.c b/src/ov_SC03_104/ov_SC03_104_after.c
index b565b2c698..242ff79fb0 100644
--- a/src/ov_SC03_104/ov_SC03_104_after.c
+++ b/src/ov_SC03_104/ov_SC03_104_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018C7B8[];
+    extern s32 (*D_8018C7B8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018C7B8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018C7B8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.c b/src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.c
index 7e75539af4..41965ae9a2 100644
--- a/src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.c
+++ b/src/ov_SC03_104/ov_SC03_104_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018B158[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B0D0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018B130;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018B0D0 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B138; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018B130;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018B138 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B158; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018B158 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018B0A0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018B0A0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018B254);
     u16 *pB = (*(u16 * *)&D_8018B250);
     u16 *pC = (*(u16 * *)&D_8018B25C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801BEDF0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801BEDF0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801BEDF0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018B258;
     extern u16 D_801BEDF0;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018B254 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018B250 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018B25C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018B254;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018B250; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B25C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018B250; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B25C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801BEDE0;
+    a1v = pac[0]; a2v = pac[2];
     D_801BEDF0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801BEDE0)) {
     found:
         pb4 = (*(u16 * *)&D_8018B258);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018B250;
     extern u8 D_8018B254;
     extern u8 D_8018B25C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018B254);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018B250); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018B25C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018B250); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018B25C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801BEDE0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801BEDF0 = 0;
+    ((H16 *)&D_801BEDF0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018B258);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_104/ov_SC03_104_jr_8015C32C.c b/src/ov_SC03_104/ov_SC03_104_jr_8015C32C.c
index 8ac11e2323..6f8b4bab15 100644
--- a/src/ov_SC03_104/ov_SC03_104_jr_8015C32C.c
+++ b/src/ov_SC03_104/ov_SC03_104_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018D35C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018D35C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_105/ov_SC03_105_after.c b/src/ov_SC03_105/ov_SC03_105_after.c
index d88869c498..a9278f9c07 100644
--- a/src/ov_SC03_105/ov_SC03_105_after.c
+++ b/src/ov_SC03_105/ov_SC03_105_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018BE40[];
+    extern s32 (*D_8018BE40[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018BE40[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018BE40[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.c b/src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.c
index 62de7e90d0..8b969e1ef1 100644
--- a/src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.c
+++ b/src/ov_SC03_105/ov_SC03_105_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018A7E0[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A758; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018A7B8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018A758 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A7C0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018A7B8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018A7C0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A7E0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018A7E0 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018A728;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018A728;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018A8DC);
     u16 *pB = (*(u16 * *)&D_8018A8D8);
     u16 *pC = (*(u16 * *)&D_8018A8E4);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B8380;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B8380 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B8380 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018A8E0;
     extern u16 D_801B8380;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018A8DC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018A8D8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018A8E4 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018A8DC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018A8D8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018A8E4); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018A8D8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018A8E4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8370;
+    a1v = pac[0]; a2v = pac[2];
     D_801B8380 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B8370)) {
     found:
         pb4 = (*(u16 * *)&D_8018A8E0);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018A8D8;
     extern u8 D_8018A8DC;
     extern u8 D_8018A8E4;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018A8DC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018A8D8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018A8E4); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018A8D8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018A8E4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B8370;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801B8380 = 0;
+    ((H16 *)&D_801B8380)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018A8E0);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_105/ov_SC03_105_jr_8015C32C.c b/src/ov_SC03_105/ov_SC03_105_jr_8015C32C.c
index a226113845..ec151bc91a 100644
--- a/src/ov_SC03_105/ov_SC03_105_jr_8015C32C.c
+++ b/src/ov_SC03_105/ov_SC03_105_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018C9E4[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018C9E4[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_107/ov_SC03_107_jr_80131340.c b/src/ov_SC03_107/ov_SC03_107_jr_80131340.c
index 1156dadc2b..0e31447a88 100644
--- a/src/ov_SC03_107/ov_SC03_107_jr_80131340.c
+++ b/src/ov_SC03_107/ov_SC03_107_jr_80131340.c
@@ -1531,15 +1531,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80182A3C);
     u16 *pB = (*(u16 * *)&D_80182A38);
     u16 *pC = (*(u16 * *)&D_80182A44);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -1550,15 +1550,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -1571,10 +1571,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2002,57 +2002,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019A788;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019A788 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019A788 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
diff --git a/src/ov_SC03_107/ov_SC03_107_jr_801458E0.c b/src/ov_SC03_107/ov_SC03_107_jr_801458E0.c
index 8a8eadbf3f..7f073f2110 100644
--- a/src/ov_SC03_107/ov_SC03_107_jr_801458E0.c
+++ b/src/ov_SC03_107/ov_SC03_107_jr_801458E0.c
@@ -1899,38 +1899,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80183FA0[];
+    extern s32 (*D_80183FA0[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80183FA0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80183FA0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_108/ov_SC03_108_after.c b/src/ov_SC03_108/ov_SC03_108_after.c
index 93663cee2d..d3b0e8a560 100644
--- a/src/ov_SC03_108/ov_SC03_108_after.c
+++ b/src/ov_SC03_108/ov_SC03_108_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80182798[];
+    extern s32 (*D_80182798[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80182798[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80182798[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.c b/src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.c
index 99b3aa17b3..5ee05d7235 100644
--- a/src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.c
+++ b/src/ov_SC03_108/ov_SC03_108_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80181138[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801810B0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80181110;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801810B0 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181118; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80181110;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80181118 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181138; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80181138 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80181080;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80181080;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80181234);
     u16 *pB = (*(u16 * *)&D_80181230);
     u16 *pC = (*(u16 * *)&D_8018123C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A0670;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A0670 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A0670 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80181238;
     extern u16 D_801A0670;
 
-    register s16 *pb0 __asm__("$9");   /* D_80181234 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80181230 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018123C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80181234;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80181230; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018123C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80181230; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018123C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A0660;
+    a1v = pac[0]; a2v = pac[2];
     D_801A0670 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A0660)) {
     found:
         pb4 = (*(u16 * *)&D_80181238);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80181230;
     extern u8 D_80181234;
     extern u8 D_8018123C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80181234);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80181230); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018123C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80181230); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018123C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A0660;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801A0670 = 0;
+    ((H16 *)&D_801A0670)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80181238);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_108/ov_SC03_108_jr_8015C32C.c b/src/ov_SC03_108/ov_SC03_108_jr_8015C32C.c
index d6490f85dc..739112582a 100644
--- a/src/ov_SC03_108/ov_SC03_108_jr_8015C32C.c
+++ b/src/ov_SC03_108/ov_SC03_108_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018333C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018333C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_109/ov_SC03_109_after.c b/src/ov_SC03_109/ov_SC03_109_after.c
index bb32a94bf5..5d1d96de68 100644
--- a/src/ov_SC03_109/ov_SC03_109_after.c
+++ b/src/ov_SC03_109/ov_SC03_109_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8017FE44[];
+    extern s32 (*D_8017FE44[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8017FE44[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8017FE44[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.c b/src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.c
index 47cb6c8de3..0782d9c6f3 100644
--- a/src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.c
+++ b/src/ov_SC03_109/ov_SC03_109_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017E7E4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E75C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017E7BC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017E75C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E7C4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017E7BC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017E7C4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E7E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017E7E4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017E72C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017E72C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017E8E0);
     u16 *pB = (*(u16 * *)&D_8017E8DC);
     u16 *pC = (*(u16 * *)&D_8017E8E8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_80199080;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_80199080 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_80199080 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017E8E4;
     extern u16 D_80199080;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017E8E0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017E8DC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017E8E8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017E8E0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017E8DC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E8E8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017E8DC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E8E8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80199070;
+    a1v = pac[0]; a2v = pac[2];
     D_80199080 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80199070)) {
     found:
         pb4 = (*(u16 * *)&D_8017E8E4);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017E8DC;
     extern u8 D_8017E8E0;
     extern u8 D_8017E8E8;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017E8E0);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017E8DC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E8E8); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017E8DC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E8E8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80199070;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_80199080 = 0;
+    ((H16 *)&D_80199080)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017E8E4);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_109/ov_SC03_109_jr_8015C32C.c b/src/ov_SC03_109/ov_SC03_109_jr_8015C32C.c
index dbef162c08..40e55ba9c4 100644
--- a/src/ov_SC03_109/ov_SC03_109_jr_8015C32C.c
+++ b/src/ov_SC03_109/ov_SC03_109_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801809E8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801809E8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_110/ov_SC03_110_after.c b/src/ov_SC03_110/ov_SC03_110_after.c
index 87932cae9b..2865e13686 100644
--- a/src/ov_SC03_110/ov_SC03_110_after.c
+++ b/src/ov_SC03_110/ov_SC03_110_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80183864[];
+    extern s32 (*D_80183864[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80183864[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80183864[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.c b/src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.c
index dba21ebafc..55eab05cf3 100644
--- a/src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.c
+++ b/src/ov_SC03_110/ov_SC03_110_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80182204[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018217C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801821DC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018217C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801821E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801821DC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801821E4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182204; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80182204 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018214C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018214C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80182300);
     u16 *pB = (*(u16 * *)&D_801822FC);
     u16 *pC = (*(u16 * *)&D_80182308);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A0E28;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A0E28 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A0E28 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80182304;
     extern u16 D_801A0E28;
 
-    register s16 *pb0 __asm__("$9");   /* D_80182300 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801822FC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80182308 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80182300;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801822FC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182308); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801822FC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182308); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A0E18;
+    a1v = pac[0]; a2v = pac[2];
     D_801A0E28 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A0E18)) {
     found:
         pb4 = (*(u16 * *)&D_80182304);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801822FC;
     extern u8 D_80182300;
     extern u8 D_80182308;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80182300);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801822FC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182308); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801822FC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182308); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A0E18;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801A0E28 = 0;
+    ((H16 *)&D_801A0E28)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80182304);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_110/ov_SC03_110_jr_8015C32C.c b/src/ov_SC03_110/ov_SC03_110_jr_8015C32C.c
index c25bbd265b..034de45567 100644
--- a/src/ov_SC03_110/ov_SC03_110_jr_8015C32C.c
+++ b/src/ov_SC03_110/ov_SC03_110_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80184408[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80184408[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_111/ov_SC03_111_after.c b/src/ov_SC03_111/ov_SC03_111_after.c
index f176c4c286..79d7464e49 100644
--- a/src/ov_SC03_111/ov_SC03_111_after.c
+++ b/src/ov_SC03_111/ov_SC03_111_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80186418[];
+    extern s32 (*D_80186418[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80186418[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80186418[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.c b/src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.c
index ac0f0e221e..d763953803 100644
--- a/src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.c
+++ b/src/ov_SC03_111/ov_SC03_111_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80184DB8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184D30; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80184D90;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80184D30 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184D98; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80184D90;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80184D98 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184DB8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80184DB8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80184D00;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80184D00;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80184EB4);
     u16 *pB = (*(u16 * *)&D_80184EB0);
     u16 *pC = (*(u16 * *)&D_80184EBC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B8330;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B8330 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B8330 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80184EB8;
     extern u16 D_801B8330;
 
-    register s16 *pb0 __asm__("$9");   /* D_80184EB4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80184EB0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80184EBC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80184EB4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80184EB0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184EBC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80184EB0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184EBC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8320;
+    a1v = pac[0]; a2v = pac[2];
     D_801B8330 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B8320)) {
     found:
         pb4 = (*(u16 * *)&D_80184EB8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80184EB0;
     extern u8 D_80184EB4;
     extern u8 D_80184EBC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80184EB4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80184EB0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184EBC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80184EB0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184EBC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B8320;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801B8330 = 0;
+    ((H16 *)&D_801B8330)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80184EB8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_111/ov_SC03_111_jr_8015C32C.c b/src/ov_SC03_111/ov_SC03_111_jr_8015C32C.c
index edb7c92a37..8baff38b55 100644
--- a/src/ov_SC03_111/ov_SC03_111_jr_8015C32C.c
+++ b/src/ov_SC03_111/ov_SC03_111_jr_8015C32C.c
@@ -1950,19 +1950,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80186FBC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80186FBC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_112/ov_SC03_112_after.c b/src/ov_SC03_112/ov_SC03_112_after.c
index b3a213bd0d..4b918c3068 100644
--- a/src/ov_SC03_112/ov_SC03_112_after.c
+++ b/src/ov_SC03_112/ov_SC03_112_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80187220[];
+    extern s32 (*D_80187220[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80187220[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80187220[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.c b/src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.c
index 1444320d30..7457ae004f 100644
--- a/src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.c
+++ b/src/ov_SC03_112/ov_SC03_112_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80185BC0[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185B38; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80185B98;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80185B38 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185BA0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80185B98;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80185BA0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185BC0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80185BC0 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80185B08;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80185B08;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80185CBC);
     u16 *pB = (*(u16 * *)&D_80185CB8);
     u16 *pC = (*(u16 * *)&D_80185CC4);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801ABB90;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801ABB90 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801ABB90 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80185CC0;
     extern u16 D_801ABB90;
 
-    register s16 *pb0 __asm__("$9");   /* D_80185CBC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80185CB8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80185CC4 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80185CBC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80185CB8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185CC4); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80185CB8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185CC4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801ABB80;
+    a1v = pac[0]; a2v = pac[2];
     D_801ABB90 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801ABB80)) {
     found:
         pb4 = (*(u16 * *)&D_80185CC0);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80185CB8;
     extern u8 D_80185CBC;
     extern u8 D_80185CC4;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80185CBC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80185CB8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80185CC4); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80185CB8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80185CC4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801ABB80;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801ABB90 = 0;
+    ((H16 *)&D_801ABB90)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80185CC0);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_112/ov_SC03_112_jr_8015C32C.c b/src/ov_SC03_112/ov_SC03_112_jr_8015C32C.c
index 39678006b2..a0bb679c58 100644
--- a/src/ov_SC03_112/ov_SC03_112_jr_8015C32C.c
+++ b/src/ov_SC03_112/ov_SC03_112_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80187DC4[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80187DC4[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_113/ov_SC03_113_after.c b/src/ov_SC03_113/ov_SC03_113_after.c
index 419a34da6e..380758a921 100644
--- a/src/ov_SC03_113/ov_SC03_113_after.c
+++ b/src/ov_SC03_113/ov_SC03_113_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801848D0[];
+    extern s32 (*D_801848D0[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801848D0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801848D0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.c b/src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.c
index f25f473dd7..57c199a08b 100644
--- a/src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.c
+++ b/src/ov_SC03_113/ov_SC03_113_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80183270[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801831E8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80183248;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801831E8 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183250; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80183248;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80183250 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183270; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80183270 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801831B8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801831B8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018336C);
     u16 *pB = (*(u16 * *)&D_80183368);
     u16 *pC = (*(u16 * *)&D_80183374);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A4720;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A4720 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A4720 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80183370;
     extern u16 D_801A4720;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018336C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80183368 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80183374 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018336C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80183368; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183374); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80183368; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183374); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A4710;
+    a1v = pac[0]; a2v = pac[2];
     D_801A4720 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A4710)) {
     found:
         pb4 = (*(u16 * *)&D_80183370);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80183368;
     extern u8 D_8018336C;
     extern u8 D_80183374;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018336C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80183368); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80183374); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80183368); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80183374); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A4710;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801A4720 = 0;
+    ((H16 *)&D_801A4720)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80183370);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_113/ov_SC03_113_jr_8015C32C.c b/src/ov_SC03_113/ov_SC03_113_jr_8015C32C.c
index 2288070a8a..d82b646999 100644
--- a/src/ov_SC03_113/ov_SC03_113_jr_8015C32C.c
+++ b/src/ov_SC03_113/ov_SC03_113_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80185474[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80185474[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_114/ov_SC03_114_after.c b/src/ov_SC03_114/ov_SC03_114_after.c
index 3107af9cb2..cd68d839e6 100644
--- a/src/ov_SC03_114/ov_SC03_114_after.c
+++ b/src/ov_SC03_114/ov_SC03_114_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80180538[];
+    extern s32 (*D_80180538[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80180538[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80180538[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.c b/src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.c
index eb4326e595..3d068d2fb7 100644
--- a/src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.c
+++ b/src/ov_SC03_114/ov_SC03_114_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017EED8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EE50; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017EEB0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017EE50 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EEB8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017EEB0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017EEB8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EED8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017EED8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017EE20;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017EE20;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017EFD4);
     u16 *pB = (*(u16 * *)&D_8017EFD0);
     u16 *pC = (*(u16 * *)&D_8017EFDC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A83B8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A83B8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A83B8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017EFD8;
     extern u16 D_801A83B8;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017EFD4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017EFD0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017EFDC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017EFD4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017EFD0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017EFDC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017EFD0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017EFDC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A83A8;
+    a1v = pac[0]; a2v = pac[2];
     D_801A83B8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A83A8)) {
     found:
         pb4 = (*(u16 * *)&D_8017EFD8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017EFD0;
     extern u8 D_8017EFD4;
     extern u8 D_8017EFDC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017EFD4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017EFD0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017EFDC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017EFD0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017EFDC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A83A8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801A83B8 = 0;
+    ((H16 *)&D_801A83B8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017EFD8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_114/ov_SC03_114_jr_8015C32C.c b/src/ov_SC03_114/ov_SC03_114_jr_8015C32C.c
index bc45daa18b..c4b93dc87b 100644
--- a/src/ov_SC03_114/ov_SC03_114_jr_8015C32C.c
+++ b/src/ov_SC03_114/ov_SC03_114_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801810DC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801810DC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_115/ov_SC03_115_after.c b/src/ov_SC03_115/ov_SC03_115_after.c
index 0050e94d33..3f5f1dd733 100644
--- a/src/ov_SC03_115/ov_SC03_115_after.c
+++ b/src/ov_SC03_115/ov_SC03_115_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80181FA4[];
+    extern s32 (*D_80181FA4[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80181FA4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80181FA4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.c b/src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.c
index e4354c74c0..b0543ecee9 100644
--- a/src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.c
+++ b/src/ov_SC03_115/ov_SC03_115_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80180944[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801808BC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018091C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801808BC + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180924; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018091C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80180924 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180944; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80180944 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018088C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018088C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80180A40);
     u16 *pB = (*(u16 * *)&D_80180A3C);
     u16 *pC = (*(u16 * *)&D_80180A48);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_80193D10;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_80193D10 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_80193D10 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80180A44;
     extern u16 D_80193D10;
 
-    register s16 *pb0 __asm__("$9");   /* D_80180A40 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80180A3C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80180A48 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80180A40;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80180A3C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180A48); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80180A3C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180A48); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80193D00;
+    a1v = pac[0]; a2v = pac[2];
     D_80193D10 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80193D00)) {
     found:
         pb4 = (*(u16 * *)&D_80180A44);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80180A3C;
     extern u8 D_80180A40;
     extern u8 D_80180A48;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80180A40);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80180A3C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80180A48); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80180A3C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80180A48); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80193D00;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_80193D10 = 0;
+    ((H16 *)&D_80193D10)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80180A44);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_115/ov_SC03_115_jr_8015C32C.c b/src/ov_SC03_115/ov_SC03_115_jr_8015C32C.c
index 5af823d4c4..f97bc748d6 100644
--- a/src/ov_SC03_115/ov_SC03_115_jr_8015C32C.c
+++ b/src/ov_SC03_115/ov_SC03_115_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80182B48[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80182B48[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_116/ov_SC03_116_after.c b/src/ov_SC03_116/ov_SC03_116_after.c
index 23f2836dbc..623f816cf4 100644
--- a/src/ov_SC03_116/ov_SC03_116_after.c
+++ b/src/ov_SC03_116/ov_SC03_116_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801843A8[];
+    extern s32 (*D_801843A8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801843A8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801843A8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.c b/src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.c
index 4dd173f0de..626d196953 100644
--- a/src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.c
+++ b/src/ov_SC03_116/ov_SC03_116_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80182D48[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182CC0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80182D20;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80182CC0 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182D28; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80182D20;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80182D28 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182D48; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80182D48 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80182C90;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80182C90;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80182E44);
     u16 *pB = (*(u16 * *)&D_80182E40);
     u16 *pC = (*(u16 * *)&D_80182E4C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801968A0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801968A0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801968A0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80182E48;
     extern u16 D_801968A0;
 
-    register s16 *pb0 __asm__("$9");   /* D_80182E44 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80182E40 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80182E4C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80182E44;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80182E40; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182E4C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80182E40; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182E4C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80196890;
+    a1v = pac[0]; a2v = pac[2];
     D_801968A0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80196890)) {
     found:
         pb4 = (*(u16 * *)&D_80182E48);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80182E40;
     extern u8 D_80182E44;
     extern u8 D_80182E4C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80182E44);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80182E40); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182E4C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80182E40); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182E4C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80196890;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801968A0 = 0;
+    ((H16 *)&D_801968A0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80182E48);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_116/ov_SC03_116_jr_8015C32C.c b/src/ov_SC03_116/ov_SC03_116_jr_8015C32C.c
index e3233c4911..676ce348be 100644
--- a/src/ov_SC03_116/ov_SC03_116_jr_8015C32C.c
+++ b/src/ov_SC03_116/ov_SC03_116_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80184F4C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80184F4C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_117/ov_SC03_117_after.c b/src/ov_SC03_117/ov_SC03_117_after.c
index 6f805c58a6..bc05d24806 100644
--- a/src/ov_SC03_117/ov_SC03_117_after.c
+++ b/src/ov_SC03_117/ov_SC03_117_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801863B4[];
+    extern s32 (*D_801863B4[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801863B4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801863B4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.c b/src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.c
index 51a737a977..d4916b5efe 100644
--- a/src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.c
+++ b/src/ov_SC03_117/ov_SC03_117_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80184D54[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184CCC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80184D2C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80184CCC + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184D34; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80184D2C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80184D34 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184D54; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80184D54 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80184C9C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80184C9C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80184E50);
     u16 *pB = (*(u16 * *)&D_80184E4C);
     u16 *pC = (*(u16 * *)&D_80184E58);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801CD018;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801CD018 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801CD018 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80184E54;
     extern u16 D_801CD018;
 
-    register s16 *pb0 __asm__("$9");   /* D_80184E50 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80184E4C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80184E58 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80184E50;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80184E4C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184E58); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80184E4C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184E58); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801CD008;
+    a1v = pac[0]; a2v = pac[2];
     D_801CD018 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801CD008)) {
     found:
         pb4 = (*(u16 * *)&D_80184E54);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80184E4C;
     extern u8 D_80184E50;
     extern u8 D_80184E58;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80184E50);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80184E4C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184E58); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80184E4C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184E58); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801CD008;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801CD018 = 0;
+    ((H16 *)&D_801CD018)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80184E54);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_117/ov_SC03_117_jr_8015C32C.c b/src/ov_SC03_117/ov_SC03_117_jr_8015C32C.c
index 22f31c7ef8..960a3e4389 100644
--- a/src/ov_SC03_117/ov_SC03_117_jr_8015C32C.c
+++ b/src/ov_SC03_117/ov_SC03_117_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80186F58[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80186F58[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_118/ov_SC03_118_after.c b/src/ov_SC03_118/ov_SC03_118_after.c
index eec88b3d65..8e24386a0e 100644
--- a/src/ov_SC03_118/ov_SC03_118_after.c
+++ b/src/ov_SC03_118/ov_SC03_118_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018B460[];
+    extern s32 (*D_8018B460[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018B460[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018B460[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.c b/src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.c
index 6951627b0f..aac21913d5 100644
--- a/src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.c
+++ b/src/ov_SC03_118/ov_SC03_118_jr_8012ACE0.c
@@ -871,156 +871,136 @@ extern s16 D_80189E00[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80189D78; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80189DD8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80189D78 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80189DE0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80189DD8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80189DE0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80189E00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80189E00 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80189D48;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80189D48;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2054,15 +2034,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80189EFC);
     u16 *pB = (*(u16 * *)&D_80189EF8);
     u16 *pC = (*(u16 * *)&D_80189F04);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2073,15 +2053,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2094,10 +2074,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2525,57 +2505,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801D2F68;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801D2F68 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801D2F68 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2686,26 +2661,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80189F00;
     extern u16 D_801D2F68;
 
-    register s16 *pb0 __asm__("$9");   /* D_80189EFC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80189EF8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80189F04 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80189EFC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80189EF8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80189F04); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80189EF8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80189F04); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801D2F58;
+    a1v = pac[0]; a2v = pac[2];
     D_801D2F68 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801D2F58)) {
     found:
         pb4 = (*(u16 * *)&D_80189F00);
         ((u16 *)p2)[0] = pb4[0];
@@ -2751,23 +2725,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80189EF8;
     extern u8 D_80189EFC;
     extern u8 D_80189F04;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80189EFC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80189EF8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80189F04); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80189EF8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80189F04); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801D2F58;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801D2F68 = 0;
+    ((H16 *)&D_801D2F68)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80189F00);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_118/ov_SC03_118_jr_8015C32C.c b/src/ov_SC03_118/ov_SC03_118_jr_8015C32C.c
index ffa51cd085..b44c81fc40 100644
--- a/src/ov_SC03_118/ov_SC03_118_jr_8015C32C.c
+++ b/src/ov_SC03_118/ov_SC03_118_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018C004[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018C004[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_121/ov_SC03_121_after.c b/src/ov_SC03_121/ov_SC03_121_after.c
index 1370db9e93..975645c657 100644
--- a/src/ov_SC03_121/ov_SC03_121_after.c
+++ b/src/ov_SC03_121/ov_SC03_121_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80183C7C[];
+    extern s32 (*D_80183C7C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80183C7C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80183C7C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.c b/src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.c
index 1f9deb547d..1ab52e88c4 100644
--- a/src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.c
+++ b/src/ov_SC03_121/ov_SC03_121_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018261C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182594; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801825F4;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80182594 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801825FC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801825F4;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801825FC + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018261C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018261C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80182564;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80182564;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80182718);
     u16 *pB = (*(u16 * *)&D_80182714);
     u16 *pC = (*(u16 * *)&D_80182720);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801ADA10;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801ADA10 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801ADA10 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018271C;
     extern u16 D_801ADA10;
 
-    register s16 *pb0 __asm__("$9");   /* D_80182718 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80182714 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80182720 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80182718;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80182714; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182720); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80182714; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182720); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801ADA00;
+    a1v = pac[0]; a2v = pac[2];
     D_801ADA10 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801ADA00)) {
     found:
         pb4 = (*(u16 * *)&D_8018271C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80182714;
     extern u8 D_80182718;
     extern u8 D_80182720;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80182718);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80182714); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182720); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80182714); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182720); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801ADA00;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801ADA10 = 0;
+    ((H16 *)&D_801ADA10)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018271C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_121/ov_SC03_121_jr_8015C32C.c b/src/ov_SC03_121/ov_SC03_121_jr_8015C32C.c
index fd5222e0b5..b4cc4d4df3 100644
--- a/src/ov_SC03_121/ov_SC03_121_jr_8015C32C.c
+++ b/src/ov_SC03_121/ov_SC03_121_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80184820[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80184820[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_124/ov_SC03_124_after.c b/src/ov_SC03_124/ov_SC03_124_after.c
index 5d77725444..9568f91da9 100644
--- a/src/ov_SC03_124/ov_SC03_124_after.c
+++ b/src/ov_SC03_124/ov_SC03_124_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018C6A8[];
+    extern s32 (*D_8018C6A8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018C6A8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018C6A8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.c b/src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.c
index e6a8db129b..a7f049c5b7 100644
--- a/src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.c
+++ b/src/ov_SC03_124/ov_SC03_124_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018B048[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018AFC0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018B020;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018AFC0 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B028; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018B020;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018B028 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018B048; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018B048 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018AF90;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018AF90;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018B144);
     u16 *pB = (*(u16 * *)&D_8018B140);
     u16 *pC = (*(u16 * *)&D_8018B14C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801E0538;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801E0538 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801E0538 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018B148;
     extern u16 D_801E0538;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018B144 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018B140 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018B14C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018B144;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018B140; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B14C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018B140; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018B14C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801E0528;
+    a1v = pac[0]; a2v = pac[2];
     D_801E0538 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801E0528)) {
     found:
         pb4 = (*(u16 * *)&D_8018B148);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018B140;
     extern u8 D_8018B144;
     extern u8 D_8018B14C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018B144);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018B140); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018B14C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018B140); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018B14C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801E0528;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801E0538 = 0;
+    ((H16 *)&D_801E0538)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018B148);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_124/ov_SC03_124_jr_8015C32C.c b/src/ov_SC03_124/ov_SC03_124_jr_8015C32C.c
index 574bc191cf..7a78f289c5 100644
--- a/src/ov_SC03_124/ov_SC03_124_jr_8015C32C.c
+++ b/src/ov_SC03_124/ov_SC03_124_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018D24C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018D24C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC03_125/ov_SC03_125_after.c b/src/ov_SC03_125/ov_SC03_125_after.c
index a37356ee0c..cf0c7f44e3 100644
--- a/src/ov_SC03_125/ov_SC03_125_after.c
+++ b/src/ov_SC03_125/ov_SC03_125_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80185878[];
+    extern s32 (*D_80185878[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80185878[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80185878[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.c b/src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.c
index c559f8dec4..7d24c4a5a0 100644
--- a/src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.c
+++ b/src/ov_SC03_125/ov_SC03_125_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80184218[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184190; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801841F0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80184190 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801841F8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801841F0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801841F8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184218; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80184218 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80184160;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80184160;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80184314);
     u16 *pB = (*(u16 * *)&D_80184310);
     u16 *pC = (*(u16 * *)&D_8018431C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C2E30;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C2E30 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C2E30 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80184318;
     extern u16 D_801C2E30;
 
-    register s16 *pb0 __asm__("$9");   /* D_80184314 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80184310 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018431C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80184314;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80184310; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018431C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80184310; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018431C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801C2E20;
+    a1v = pac[0]; a2v = pac[2];
     D_801C2E30 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801C2E20)) {
     found:
         pb4 = (*(u16 * *)&D_80184318);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80184310;
     extern u8 D_80184314;
     extern u8 D_8018431C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80184314);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80184310); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018431C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80184310); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018431C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801C2E20;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801C2E30 = 0;
+    ((H16 *)&D_801C2E30)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80184318);
         p2[0] = pb4[0];
diff --git a/src/ov_SC03_125/ov_SC03_125_jr_8015C32C.c b/src/ov_SC03_125/ov_SC03_125_jr_8015C32C.c
index e64769ef7d..fc2ebce7f7 100644
--- a/src/ov_SC03_125/ov_SC03_125_jr_8015C32C.c
+++ b/src/ov_SC03_125/ov_SC03_125_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018641C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018641C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_000/ov_SC04_000_after.c b/src/ov_SC04_000/ov_SC04_000_after.c
index 4d618f2065..7cb1efa879 100644
--- a/src/ov_SC04_000/ov_SC04_000_after.c
+++ b/src/ov_SC04_000/ov_SC04_000_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80184D7C[];
+    extern s32 (*D_80184D7C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80184D7C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80184D7C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.c b/src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.c
index faa75915df..ed519ee7e3 100644
--- a/src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.c
+++ b/src/ov_SC04_000/ov_SC04_000_jr_8012ACE0.c
@@ -1126,156 +1126,136 @@ extern s16 D_8018371C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183694; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801836F4;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80183694 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801836FC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801836F4;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801836FC + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018371C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018371C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80183664;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80183664;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2309,15 +2289,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80183818);
     u16 *pB = (*(u16 * *)&D_80183814);
     u16 *pC = (*(u16 * *)&D_80183820);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2328,15 +2308,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2349,10 +2329,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2780,57 +2760,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A87A8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A87A8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A87A8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2941,26 +2916,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018381C;
     extern u16 D_801A87A8;
 
-    register s16 *pb0 __asm__("$9");   /* D_80183818 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80183814 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80183820 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80183818;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80183814; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183820); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80183814; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80183820); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A8798;
+    a1v = pac[0]; a2v = pac[2];
     D_801A87A8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A8798)) {
     found:
         pb4 = (*(u16 * *)&D_8018381C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3006,23 +2980,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80183814;
     extern u8 D_80183818;
     extern u8 D_80183820;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80183818);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80183814); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80183820); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80183814); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80183820); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A8798;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801A87A8 = 0;
+    ((H16 *)&D_801A87A8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018381C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_000/ov_SC04_000_jr_8015C32C.c b/src/ov_SC04_000/ov_SC04_000_jr_8015C32C.c
index e1f0adb9ac..20dd2cf02f 100644
--- a/src/ov_SC04_000/ov_SC04_000_jr_8015C32C.c
+++ b/src/ov_SC04_000/ov_SC04_000_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80185920[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80185920[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_002/ov_SC04_002_after.c b/src/ov_SC04_002/ov_SC04_002_after.c
index 9036cf46df..27783822c5 100644
--- a/src/ov_SC04_002/ov_SC04_002_after.c
+++ b/src/ov_SC04_002/ov_SC04_002_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80189EE8[];
+    extern s32 (*D_80189EE8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80189EE8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80189EE8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.c b/src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.c
index aac3b89000..aa83ffb263 100644
--- a/src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.c
+++ b/src/ov_SC04_002/ov_SC04_002_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80188888[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188800; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80188860;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80188800 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188868; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80188860;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80188868 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188888; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80188888 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801887D0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801887D0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80188984);
     u16 *pB = (*(u16 * *)&D_80188980);
     u16 *pC = (*(u16 * *)&D_8018898C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801BFAB8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801BFAB8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801BFAB8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80188988;
     extern u16 D_801BFAB8;
 
-    register s16 *pb0 __asm__("$9");   /* D_80188984 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80188980 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018898C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80188984;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80188980; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018898C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80188980; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018898C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801BFAA8;
+    a1v = pac[0]; a2v = pac[2];
     D_801BFAB8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801BFAA8)) {
     found:
         pb4 = (*(u16 * *)&D_80188988);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80188980;
     extern u8 D_80188984;
     extern u8 D_8018898C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80188984);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80188980); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018898C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80188980); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018898C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801BFAA8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801BFAB8 = 0;
+    ((H16 *)&D_801BFAB8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80188988);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_002/ov_SC04_002_jr_8015C32C.c b/src/ov_SC04_002/ov_SC04_002_jr_8015C32C.c
index 1e8fa8fd04..43f7771281 100644
--- a/src/ov_SC04_002/ov_SC04_002_jr_8015C32C.c
+++ b/src/ov_SC04_002/ov_SC04_002_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018AA8C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018AA8C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_003/ov_SC04_003_after.c b/src/ov_SC04_003/ov_SC04_003_after.c
index 0c5cc07537..5825e096a1 100644
--- a/src/ov_SC04_003/ov_SC04_003_after.c
+++ b/src/ov_SC04_003/ov_SC04_003_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80183C84[];
+    extern s32 (*D_80183C84[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80183C84[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80183C84[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.c b/src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.c
index d19221768a..aefe7f5a34 100644
--- a/src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.c
+++ b/src/ov_SC04_003/ov_SC04_003_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80182624[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018259C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801825FC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018259C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182604; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801825FC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80182604 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182624; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80182624 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018256C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018256C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80182720);
     u16 *pB = (*(u16 * *)&D_8018271C);
     u16 *pC = (*(u16 * *)&D_80182728);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019A720;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019A720 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019A720 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80182724;
     extern u16 D_8019A720;
 
-    register s16 *pb0 __asm__("$9");   /* D_80182720 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018271C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80182728 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80182720;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018271C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182728); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018271C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182728); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019A710;
+    a1v = pac[0]; a2v = pac[2];
     D_8019A720 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019A710)) {
     found:
         pb4 = (*(u16 * *)&D_80182724);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018271C;
     extern u8 D_80182720;
     extern u8 D_80182728;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80182720);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018271C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182728); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018271C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182728); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019A710;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_8019A720 = 0;
+    ((H16 *)&D_8019A720)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80182724);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_003/ov_SC04_003_jr_8015C32C.c b/src/ov_SC04_003/ov_SC04_003_jr_8015C32C.c
index ab694fe745..eb326ce659 100644
--- a/src/ov_SC04_003/ov_SC04_003_jr_8015C32C.c
+++ b/src/ov_SC04_003/ov_SC04_003_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80184828[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80184828[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_004/ov_SC04_004_after.c b/src/ov_SC04_004/ov_SC04_004_after.c
index b837f81143..634c0f638f 100644
--- a/src/ov_SC04_004/ov_SC04_004_after.c
+++ b/src/ov_SC04_004/ov_SC04_004_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801861B8[];
+    extern s32 (*D_801861B8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801861B8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801861B8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.c b/src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.c
index 2b39351fd4..5964b12edb 100644
--- a/src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.c
+++ b/src/ov_SC04_004/ov_SC04_004_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80184B58[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184AD0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80184B30;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80184AD0 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184B38; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80184B30;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80184B38 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184B58; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80184B58 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80184AA0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80184AA0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80184C54);
     u16 *pB = (*(u16 * *)&D_80184C50);
     u16 *pC = (*(u16 * *)&D_80184C5C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B2520;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B2520 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B2520 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80184C58;
     extern u16 D_801B2520;
 
-    register s16 *pb0 __asm__("$9");   /* D_80184C54 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80184C50 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80184C5C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80184C54;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80184C50; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184C5C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80184C50; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184C5C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B2510;
+    a1v = pac[0]; a2v = pac[2];
     D_801B2520 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B2510)) {
     found:
         pb4 = (*(u16 * *)&D_80184C58);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80184C50;
     extern u8 D_80184C54;
     extern u8 D_80184C5C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80184C54);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80184C50); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184C5C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80184C50); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184C5C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B2510;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801B2520 = 0;
+    ((H16 *)&D_801B2520)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80184C58);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_004/ov_SC04_004_jr_8015C32C.c b/src/ov_SC04_004/ov_SC04_004_jr_8015C32C.c
index 2058c33112..07a9e2ce36 100644
--- a/src/ov_SC04_004/ov_SC04_004_jr_8015C32C.c
+++ b/src/ov_SC04_004/ov_SC04_004_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80186D5C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80186D5C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_005/ov_SC04_005_after.c b/src/ov_SC04_005/ov_SC04_005_after.c
index 7e80ae0e48..abafa71e26 100644
--- a/src/ov_SC04_005/ov_SC04_005_after.c
+++ b/src/ov_SC04_005/ov_SC04_005_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801895EC[];
+    extern s32 (*D_801895EC[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801895EC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801895EC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.c b/src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.c
index a856a358cb..5f89a864bb 100644
--- a/src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.c
+++ b/src/ov_SC04_005/ov_SC04_005_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80187F8C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187F04; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80187F64;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80187F04 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187F6C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80187F64;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80187F6C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80187F8C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80187F8C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80187ED4;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80187ED4;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80188088);
     u16 *pB = (*(u16 * *)&D_80188084);
     u16 *pC = (*(u16 * *)&D_80188090);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C06F8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C06F8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C06F8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018808C;
     extern u16 D_801C06F8;
 
-    register s16 *pb0 __asm__("$9");   /* D_80188088 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80188084 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80188090 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80188088;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80188084; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80188090); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80188084; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80188090); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801C06E8;
+    a1v = pac[0]; a2v = pac[2];
     D_801C06F8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801C06E8)) {
     found:
         pb4 = (*(u16 * *)&D_8018808C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80188084;
     extern u8 D_80188088;
     extern u8 D_80188090;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80188088);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80188084); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80188090); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80188084); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80188090); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801C06E8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801C06F8 = 0;
+    ((H16 *)&D_801C06F8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018808C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_005/ov_SC04_005_jr_8015C32C.c b/src/ov_SC04_005/ov_SC04_005_jr_8015C32C.c
index 30fc449325..4f7c04fe93 100644
--- a/src/ov_SC04_005/ov_SC04_005_jr_8015C32C.c
+++ b/src/ov_SC04_005/ov_SC04_005_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018A190[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018A190[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_006/ov_SC04_006_after.c b/src/ov_SC04_006/ov_SC04_006_after.c
index 0447265f1a..c50be88af9 100644
--- a/src/ov_SC04_006/ov_SC04_006_after.c
+++ b/src/ov_SC04_006/ov_SC04_006_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801816CC[];
+    extern s32 (*D_801816CC[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801816CC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801816CC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.c b/src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.c
index 0a64cddeec..e4ad764e1f 100644
--- a/src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.c
+++ b/src/ov_SC04_006/ov_SC04_006_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018006C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017FFE4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80180044;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017FFE4 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018004C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80180044;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018004C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018006C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018006C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017FFB4;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017FFB4;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80180168);
     u16 *pB = (*(u16 * *)&D_80180164);
     u16 *pC = (*(u16 * *)&D_80180170);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019C9A0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019C9A0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019C9A0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018016C;
     extern u16 D_8019C9A0;
 
-    register s16 *pb0 __asm__("$9");   /* D_80180168 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80180164 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80180170 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80180168;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80180164; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180170); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80180164; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180170); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019C990;
+    a1v = pac[0]; a2v = pac[2];
     D_8019C9A0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019C990)) {
     found:
         pb4 = (*(u16 * *)&D_8018016C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80180164;
     extern u8 D_80180168;
     extern u8 D_80180170;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80180168);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80180164); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80180170); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80180164); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80180170); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019C990;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_8019C9A0 = 0;
+    ((H16 *)&D_8019C9A0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018016C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_006/ov_SC04_006_jr_8015C32C.c b/src/ov_SC04_006/ov_SC04_006_jr_8015C32C.c
index 193082343b..bad796f964 100644
--- a/src/ov_SC04_006/ov_SC04_006_jr_8015C32C.c
+++ b/src/ov_SC04_006/ov_SC04_006_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80182270[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80182270[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_007/ov_SC04_007_after.c b/src/ov_SC04_007/ov_SC04_007_after.c
index 13a100ea34..7009ebecea 100644
--- a/src/ov_SC04_007/ov_SC04_007_after.c
+++ b/src/ov_SC04_007/ov_SC04_007_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80187684[];
+    extern s32 (*D_80187684[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80187684[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80187684[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.c b/src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.c
index 67d77b86e4..2c8e999fcf 100644
--- a/src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.c
+++ b/src/ov_SC04_007/ov_SC04_007_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80186024[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185F9C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80185FFC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80185F9C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186004; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80185FFC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80186004 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186024; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80186024 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80185F6C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80185F6C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80186120);
     u16 *pB = (*(u16 * *)&D_8018611C);
     u16 *pC = (*(u16 * *)&D_80186128);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B3F58;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B3F58 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B3F58 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80186124;
     extern u16 D_801B3F58;
 
-    register s16 *pb0 __asm__("$9");   /* D_80186120 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018611C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80186128 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80186120;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018611C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186128); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018611C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186128); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B3F48;
+    a1v = pac[0]; a2v = pac[2];
     D_801B3F58 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B3F48)) {
     found:
         pb4 = (*(u16 * *)&D_80186124);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018611C;
     extern u8 D_80186120;
     extern u8 D_80186128;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80186120);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018611C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186128); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018611C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186128); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B3F48;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801B3F58 = 0;
+    ((H16 *)&D_801B3F58)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80186124);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_007/ov_SC04_007_jr_8015C32C.c b/src/ov_SC04_007/ov_SC04_007_jr_8015C32C.c
index f5359c67bd..6aa0f00aea 100644
--- a/src/ov_SC04_007/ov_SC04_007_jr_8015C32C.c
+++ b/src/ov_SC04_007/ov_SC04_007_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80188228[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80188228[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.c b/src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.c
index 6e38518a87..bc61cb338d 100644
--- a/src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.c
+++ b/src/ov_SC04_008/ov_SC04_008_jr_8012ACE0.c
@@ -1765,15 +1765,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017F058);
     u16 *pB = (*(u16 * *)&D_8017F054);
     u16 *pC = (*(u16 * *)&D_8017F060);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -1784,15 +1784,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -1805,10 +1805,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2187,57 +2187,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_80190C30;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_80190C30 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_80190C30 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2348,26 +2343,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017F05C;
     extern u16 D_80190C30;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017F058 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017F054 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017F060 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017F058;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017F054; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017F054; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80190C20;
+    a1v = pac[0]; a2v = pac[2];
     D_80190C30 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80190C20)) {
     found:
         pb4 = (*(u16 * *)&D_8017F05C);
         ((u16 *)p2)[0] = pb4[0];
@@ -2413,23 +2407,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017F054;
     extern u8 D_8017F058;
     extern u8 D_8017F060;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017F058);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017F054); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017F054); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80190C20;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_80190C30 = 0;
+    ((H16 *)&D_80190C30)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017F05C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_009/ov_SC04_009_after.c b/src/ov_SC04_009/ov_SC04_009_after.c
index e252f9337a..83e75e6b2f 100644
--- a/src/ov_SC04_009/ov_SC04_009_after.c
+++ b/src/ov_SC04_009/ov_SC04_009_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801805E8[];
+    extern s32 (*D_801805E8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801805E8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801805E8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.c b/src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.c
index ab7b04c82b..a88ac04c0b 100644
--- a/src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.c
+++ b/src/ov_SC04_009/ov_SC04_009_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017EF88[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017EF60;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017EF00 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF68; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017EF60;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017EF68 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF88; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017EF88 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017EED0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017EED0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017F084);
     u16 *pB = (*(u16 * *)&D_8017F080);
     u16 *pC = (*(u16 * *)&D_8017F08C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_80196E40;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_80196E40 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_80196E40 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017F088;
     extern u16 D_80196E40;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017F084 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017F080 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017F08C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017F084;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017F080; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F08C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017F080; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F08C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80196E30;
+    a1v = pac[0]; a2v = pac[2];
     D_80196E40 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80196E30)) {
     found:
         pb4 = (*(u16 * *)&D_8017F088);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017F080;
     extern u8 D_8017F084;
     extern u8 D_8017F08C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017F084);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017F080); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F08C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017F080); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F08C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80196E30;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_80196E40 = 0;
+    ((H16 *)&D_80196E40)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017F088);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_009/ov_SC04_009_jr_8015C32C.c b/src/ov_SC04_009/ov_SC04_009_jr_8015C32C.c
index 2be45dc9a0..519de52276 100644
--- a/src/ov_SC04_009/ov_SC04_009_jr_8015C32C.c
+++ b/src/ov_SC04_009/ov_SC04_009_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018118C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018118C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_010/ov_SC04_010_after.c b/src/ov_SC04_010/ov_SC04_010_after.c
index 94966d34c0..dbfa61658b 100644
--- a/src/ov_SC04_010/ov_SC04_010_after.c
+++ b/src/ov_SC04_010/ov_SC04_010_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8017FC94[];
+    extern s32 (*D_8017FC94[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8017FC94[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8017FC94[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.c b/src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.c
index b02c06b97a..93f3980f26 100644
--- a/src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.c
+++ b/src/ov_SC04_010/ov_SC04_010_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017E634[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E5AC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017E60C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017E5AC + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E614; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017E60C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017E614 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E634; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017E634 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017E57C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017E57C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017E730);
     u16 *pB = (*(u16 * *)&D_8017E72C);
     u16 *pC = (*(u16 * *)&D_8017E738);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8018E2D8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8018E2D8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8018E2D8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017E734;
     extern u16 D_8018E2D8;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017E730 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017E72C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017E738 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017E730;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017E72C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E738); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017E72C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E738); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8018E2C8;
+    a1v = pac[0]; a2v = pac[2];
     D_8018E2D8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8018E2C8)) {
     found:
         pb4 = (*(u16 * *)&D_8017E734);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017E72C;
     extern u8 D_8017E730;
     extern u8 D_8017E738;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017E730);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017E72C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E738); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017E72C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E738); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8018E2C8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_8018E2D8 = 0;
+    ((H16 *)&D_8018E2D8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017E734);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_010/ov_SC04_010_jr_8015C32C.c b/src/ov_SC04_010/ov_SC04_010_jr_8015C32C.c
index f70e766c28..caef70e265 100644
--- a/src/ov_SC04_010/ov_SC04_010_jr_8015C32C.c
+++ b/src/ov_SC04_010/ov_SC04_010_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80180838[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80180838[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_011/ov_SC04_011_after.c b/src/ov_SC04_011/ov_SC04_011_after.c
index 667cda6edc..486d2ee547 100644
--- a/src/ov_SC04_011/ov_SC04_011_after.c
+++ b/src/ov_SC04_011/ov_SC04_011_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80191F24[];
+    extern s32 (*D_80191F24[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B t3_tus1)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B t3_tus1)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80191F24[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80191F24[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B t3_tus1)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B t3_tus1)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B t3_tus1)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B t3_tus1)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c b/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c
index 27bbcda30e..b3e67a2435 100644
--- a/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c
+++ b/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801908C4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B t3_tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8019083C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B t3_tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8019089C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8019083C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801908A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B t3_tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8019089C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801908A4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801908C4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B t3_tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801908C4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8019080C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8019080C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801909C0);
     u16 *pB = (*(u16 * *)&D_801909BC);
     u16 *pC = (*(u16 * *)&D_801909C8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B t3_tus1)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B t3_tus1)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B t3_tus1)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B t3_tus1)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801EDA40;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B t3_tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B t3_tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B t3_tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B t3_tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801EDA40 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B t3_tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801EDA40 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801909C4;
     extern u16 D_801EDA40;
 
-    register s16 *pb0 __asm__("$9");   /* D_801909C0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B t3_tus1)
-    register s16 *pac __asm__("$6");   /* D_801909BC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B t3_tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801909C8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B t3_tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801909C0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B t3_tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801909BC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801909BC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801EDA30;
+    a1v = pac[0]; a2v = pac[2];
     D_801EDA40 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801EDA30)) {
     found:
         pb4 = (*(u16 * *)&D_801909C4);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801909BC;
     extern u8 D_801909C0;
     extern u8 D_801909C8;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B t3_tus1)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B t3_tus1)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B t3_tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801909C0);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B t3_tus1)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801909BC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801909BC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801909C8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801EDA30;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B t3_tus1)
-    D_801EDA40 = 0;
+    ((H16 *)&D_801EDA40)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801909C4);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c b/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c
index c6f0adf32b..567d68ddb7 100644
--- a/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c
+++ b/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80192AC8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B t3_tus1)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80192AC8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_012/ov_SC04_012_after.c b/src/ov_SC04_012/ov_SC04_012_after.c
index 27152e505f..760f5367f8 100644
--- a/src/ov_SC04_012/ov_SC04_012_after.c
+++ b/src/ov_SC04_012/ov_SC04_012_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801800F8[];
+    extern s32 (*D_801800F8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801800F8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801800F8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.c b/src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.c
index 82b289e9fb..d6cf73d8ea 100644
--- a/src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.c
+++ b/src/ov_SC04_012/ov_SC04_012_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017EA98[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA10; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017EA70;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017EA10 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA78; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017EA70;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017EA78 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA98; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017EA98 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017E9E0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017E9E0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017EB94);
     u16 *pB = (*(u16 * *)&D_8017EB90);
     u16 *pC = (*(u16 * *)&D_8017EB9C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801909B0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801909B0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801909B0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017EB98;
     extern u16 D_801909B0;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017EB94 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017EB90 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017EB9C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017EB94;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017EB90; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017EB9C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017EB90; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017EB9C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801909A0;
+    a1v = pac[0]; a2v = pac[2];
     D_801909B0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801909A0)) {
     found:
         pb4 = (*(u16 * *)&D_8017EB98);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017EB90;
     extern u8 D_8017EB94;
     extern u8 D_8017EB9C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017EB94);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017EB90); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017EB9C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017EB90); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017EB9C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801909A0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801909B0 = 0;
+    ((H16 *)&D_801909B0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017EB98);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_012/ov_SC04_012_jr_8015C32C.c b/src/ov_SC04_012/ov_SC04_012_jr_8015C32C.c
index 1401ceacdb..058589259c 100644
--- a/src/ov_SC04_012/ov_SC04_012_jr_8015C32C.c
+++ b/src/ov_SC04_012/ov_SC04_012_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80180C9C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80180C9C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_015/ov_SC04_015_after.c b/src/ov_SC04_015/ov_SC04_015_after.c
index df156ecc09..51ab3bde8c 100644
--- a/src/ov_SC04_015/ov_SC04_015_after.c
+++ b/src/ov_SC04_015/ov_SC04_015_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80186030[];
+    extern s32 (*D_80186030[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80186030[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80186030[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.c b/src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.c
index 505e227646..fbe0b9647d 100644
--- a/src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.c
+++ b/src/ov_SC04_015/ov_SC04_015_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801849D0[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80184948; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801849A8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80184948 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801849B0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801849A8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801849B0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801849D0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801849D0 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80184918;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80184918;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80184ACC);
     u16 *pB = (*(u16 * *)&D_80184AC8);
     u16 *pC = (*(u16 * *)&D_80184AD4);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C7698;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C7698 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C7698 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80184AD0;
     extern u16 D_801C7698;
 
-    register s16 *pb0 __asm__("$9");   /* D_80184ACC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80184AC8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80184AD4 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80184ACC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80184AC8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184AD4); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80184AC8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80184AD4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801C7688;
+    a1v = pac[0]; a2v = pac[2];
     D_801C7698 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801C7688)) {
     found:
         pb4 = (*(u16 * *)&D_80184AD0);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80184AC8;
     extern u8 D_80184ACC;
     extern u8 D_80184AD4;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80184ACC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80184AC8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80184AD4); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80184AC8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80184AD4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801C7688;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801C7698 = 0;
+    ((H16 *)&D_801C7698)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80184AD0);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_015/ov_SC04_015_jr_8015C32C.c b/src/ov_SC04_015/ov_SC04_015_jr_8015C32C.c
index 593cfcad94..67db80efd1 100644
--- a/src/ov_SC04_015/ov_SC04_015_jr_8015C32C.c
+++ b/src/ov_SC04_015/ov_SC04_015_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80186BD4[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80186BD4[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_016/ov_SC04_016_after.c b/src/ov_SC04_016/ov_SC04_016_after.c
index bb687f34b5..ecd15693a5 100644
--- a/src/ov_SC04_016/ov_SC04_016_after.c
+++ b/src/ov_SC04_016/ov_SC04_016_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80181AF4[];
+    extern s32 (*D_80181AF4[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80181AF4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80181AF4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.c b/src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.c
index 8d460004b5..76e3f153a8 100644
--- a/src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.c
+++ b/src/ov_SC04_016/ov_SC04_016_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80180494[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018040C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018046C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018040C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180474; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018046C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80180474 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180494; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80180494 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801803DC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801803DC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80180590);
     u16 *pB = (*(u16 * *)&D_8018058C);
     u16 *pC = (*(u16 * *)&D_80180598);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A5840;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A5840 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A5840 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80180594;
     extern u16 D_801A5840;
 
-    register s16 *pb0 __asm__("$9");   /* D_80180590 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018058C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80180598 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80180590;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018058C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180598); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018058C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180598); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A5830;
+    a1v = pac[0]; a2v = pac[2];
     D_801A5840 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A5830)) {
     found:
         pb4 = (*(u16 * *)&D_80180594);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018058C;
     extern u8 D_80180590;
     extern u8 D_80180598;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80180590);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018058C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80180598); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018058C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80180598); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A5830;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801A5840 = 0;
+    ((H16 *)&D_801A5840)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80180594);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_016/ov_SC04_016_jr_8015C32C.c b/src/ov_SC04_016/ov_SC04_016_jr_8015C32C.c
index 28e5a0406d..103144363a 100644
--- a/src/ov_SC04_016/ov_SC04_016_jr_8015C32C.c
+++ b/src/ov_SC04_016/ov_SC04_016_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80182698[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80182698[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_018/ov_SC04_018_after.c b/src/ov_SC04_018/ov_SC04_018_after.c
index 1de28d6821..a1c70d4741 100644
--- a/src/ov_SC04_018/ov_SC04_018_after.c
+++ b/src/ov_SC04_018/ov_SC04_018_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018ED0C[];
+    extern s32 (*D_8018ED0C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018ED0C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018ED0C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.c b/src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.c
index e2f8338f76..4134de45e8 100644
--- a/src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.c
+++ b/src/ov_SC04_018/ov_SC04_018_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018D6AC[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D624; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018D684;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018D624 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D68C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018D684;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018D68C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D6AC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018D6AC + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018D5F4;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018D5F4;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018D7A8);
     u16 *pB = (*(u16 * *)&D_8018D7A4);
     u16 *pC = (*(u16 * *)&D_8018D7B0);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801E5A90;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801E5A90 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801E5A90 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018D7AC;
     extern u16 D_801E5A90;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018D7A8 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8018D7A4 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8018D7B0 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018D7A8;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8018D7A4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018D7B0); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018D7A4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018D7B0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801E5A80;
+    a1v = pac[0]; a2v = pac[2];
     D_801E5A90 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801E5A80)) {
     found:
         pb4 = (*(u16 * *)&D_8018D7AC);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018D7A4;
     extern u8 D_8018D7A8;
     extern u8 D_8018D7B0;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018D7A8);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018D7A4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018D7B0); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018D7A4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018D7B0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801E5A80;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801E5A90 = 0;
+    ((H16 *)&D_801E5A90)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018D7AC);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_018/ov_SC04_018_jr_8015C32C.c b/src/ov_SC04_018/ov_SC04_018_jr_8015C32C.c
index ac5900fb82..7ecb665c0e 100644
--- a/src/ov_SC04_018/ov_SC04_018_jr_8015C32C.c
+++ b/src/ov_SC04_018/ov_SC04_018_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018F8B0[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018F8B0[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC04_020/ov_SC04_020_after.c b/src/ov_SC04_020/ov_SC04_020_after.c
index 70e6bd6e6f..3fbf379600 100644
--- a/src/ov_SC04_020/ov_SC04_020_after.c
+++ b/src/ov_SC04_020/ov_SC04_020_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80184E44[];
+    extern s32 (*D_80184E44[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80184E44[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80184E44[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.c b/src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.c
index df23a9fe5a..b49e668129 100644
--- a/src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.c
+++ b/src/ov_SC04_020/ov_SC04_020_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801837E4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018375C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801837BC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018375C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801837C4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801837BC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801837C4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801837E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801837E4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018372C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018372C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801838E0);
     u16 *pB = (*(u16 * *)&D_801838DC);
     u16 *pC = (*(u16 * *)&D_801838E8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801BB0A0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801BB0A0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801BB0A0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801838E4;
     extern u16 D_801BB0A0;
 
-    register s16 *pb0 __asm__("$9");   /* D_801838E0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801838DC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801838E8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801838E0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801838DC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801838E8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801838DC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801838E8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801BB090;
+    a1v = pac[0]; a2v = pac[2];
     D_801BB0A0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801BB090)) {
     found:
         pb4 = (*(u16 * *)&D_801838E4);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801838DC;
     extern u8 D_801838E0;
     extern u8 D_801838E8;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801838E0);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801838DC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801838E8); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801838DC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801838E8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801BB090;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801BB0A0 = 0;
+    ((H16 *)&D_801BB0A0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801838E4);
         p2[0] = pb4[0];
diff --git a/src/ov_SC04_020/ov_SC04_020_jr_8015C32C.c b/src/ov_SC04_020/ov_SC04_020_jr_8015C32C.c
index dfb7e4573e..9ebee2d4a6 100644
--- a/src/ov_SC04_020/ov_SC04_020_jr_8015C32C.c
+++ b/src/ov_SC04_020/ov_SC04_020_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801859E8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801859E8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_000/ov_SC05_000_after.c b/src/ov_SC05_000/ov_SC05_000_after.c
index b27e82a8e0..5335cb906c 100644
--- a/src/ov_SC05_000/ov_SC05_000_after.c
+++ b/src/ov_SC05_000/ov_SC05_000_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8017FD84[];
+    extern s32 (*D_8017FD84[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8017FD84[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8017FD84[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.c b/src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.c
index 9e17d457a3..7832e3e2bd 100644
--- a/src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.c
+++ b/src/ov_SC05_000/ov_SC05_000_jr_8012ACE0.c
@@ -1126,156 +1126,136 @@ extern s16 D_8017E724[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E69C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017E6FC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017E69C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E704; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017E6FC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017E704 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E724; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017E724 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017E66C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017E66C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2309,15 +2289,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017E820);
     u16 *pB = (*(u16 * *)&D_8017E81C);
     u16 *pC = (*(u16 * *)&D_8017E828);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2328,15 +2308,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2349,10 +2329,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2780,57 +2760,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_80199828;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_80199828 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_80199828 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2941,26 +2916,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017E824;
     extern u16 D_80199828;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017E820 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017E81C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017E828 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017E820;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017E81C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E828); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017E81C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E828); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80199818;
+    a1v = pac[0]; a2v = pac[2];
     D_80199828 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80199818)) {
     found:
         pb4 = (*(u16 * *)&D_8017E824);
         ((u16 *)p2)[0] = pb4[0];
@@ -3006,23 +2980,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017E81C;
     extern u8 D_8017E820;
     extern u8 D_8017E828;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017E820);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017E81C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E828); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017E81C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E828); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80199818;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_80199828 = 0;
+    ((H16 *)&D_80199828)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017E824);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_000/ov_SC05_000_jr_8015C32C.c b/src/ov_SC05_000/ov_SC05_000_jr_8015C32C.c
index 566bd5fa20..e8695e2a80 100644
--- a/src/ov_SC05_000/ov_SC05_000_jr_8015C32C.c
+++ b/src/ov_SC05_000/ov_SC05_000_jr_8015C32C.c
@@ -1947,19 +1947,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80180928[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80180928[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_001/ov_SC05_001_after.c b/src/ov_SC05_001/ov_SC05_001_after.c
index a5c0ca8f67..b369bf4779 100644
--- a/src/ov_SC05_001/ov_SC05_001_after.c
+++ b/src/ov_SC05_001/ov_SC05_001_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80187560[];
+    extern s32 (*D_80187560[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80187560[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80187560[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.c b/src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.c
index a0fb239769..108f107d48 100644
--- a/src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.c
+++ b/src/ov_SC05_001/ov_SC05_001_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80185F00[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185E78; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80185ED8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80185E78 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185EE0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80185ED8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80185EE0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185F00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80185F00 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80185E48;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80185E48;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80185FFC);
     u16 *pB = (*(u16 * *)&D_80185FF8);
     u16 *pC = (*(u16 * *)&D_80186004);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B48E8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B48E8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B48E8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80186000;
     extern u16 D_801B48E8;
 
-    register s16 *pb0 __asm__("$9");   /* D_80185FFC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80185FF8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80186004 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80185FFC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80185FF8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186004); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80185FF8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186004); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B48D8;
+    a1v = pac[0]; a2v = pac[2];
     D_801B48E8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B48D8)) {
     found:
         pb4 = (*(u16 * *)&D_80186000);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80185FF8;
     extern u8 D_80185FFC;
     extern u8 D_80186004;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80185FFC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80185FF8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186004); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80185FF8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186004); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B48D8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801B48E8 = 0;
+    ((H16 *)&D_801B48E8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80186000);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_001/ov_SC05_001_jr_8015C32C.c b/src/ov_SC05_001/ov_SC05_001_jr_8015C32C.c
index 32fb7d2719..2081b16c29 100644
--- a/src/ov_SC05_001/ov_SC05_001_jr_8015C32C.c
+++ b/src/ov_SC05_001/ov_SC05_001_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80188104[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80188104[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_002/ov_SC05_002_after.c b/src/ov_SC05_002/ov_SC05_002_after.c
index 11ef878ccb..16a0800cdc 100644
--- a/src/ov_SC05_002/ov_SC05_002_after.c
+++ b/src/ov_SC05_002/ov_SC05_002_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80181D20[];
+    extern s32 (*D_80181D20[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80181D20[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80181D20[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.c b/src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.c
index 365e1db942..0e4bcc7a66 100644
--- a/src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.c
+++ b/src/ov_SC05_002/ov_SC05_002_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801806C0[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180638; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80180698;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80180638 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801806A0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80180698;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801806A0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801806C0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801806C0 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80180608;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80180608;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801807BC);
     u16 *pB = (*(u16 * *)&D_801807B8);
     u16 *pC = (*(u16 * *)&D_801807C4);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019EB88;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019EB88 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019EB88 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801807C0;
     extern u16 D_8019EB88;
 
-    register s16 *pb0 __asm__("$9");   /* D_801807BC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801807B8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801807C4 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801807BC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801807B8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801807C4); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801807B8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801807C4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019EB78;
+    a1v = pac[0]; a2v = pac[2];
     D_8019EB88 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019EB78)) {
     found:
         pb4 = (*(u16 * *)&D_801807C0);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801807B8;
     extern u8 D_801807BC;
     extern u8 D_801807C4;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801807BC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801807B8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801807C4); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801807B8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801807C4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019EB78;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_8019EB88 = 0;
+    ((H16 *)&D_8019EB88)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801807C0);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_002/ov_SC05_002_jr_8015C32C.c b/src/ov_SC05_002/ov_SC05_002_jr_8015C32C.c
index cf5110c73d..af38f1ca64 100644
--- a/src/ov_SC05_002/ov_SC05_002_jr_8015C32C.c
+++ b/src/ov_SC05_002/ov_SC05_002_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801828C4[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801828C4[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_003/ov_SC05_003_after.c b/src/ov_SC05_003/ov_SC05_003_after.c
index 38cd9a3162..430b347334 100644
--- a/src/ov_SC05_003/ov_SC05_003_after.c
+++ b/src/ov_SC05_003/ov_SC05_003_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80184058[];
+    extern s32 (*D_80184058[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80184058[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80184058[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.c b/src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.c
index dc0dfca97d..df647fdec1 100644
--- a/src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.c
+++ b/src/ov_SC05_003/ov_SC05_003_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801829F8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182970; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801829D0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80182970 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801829D8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801829D0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801829D8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801829F8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801829F8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80182940;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80182940;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80182AF4);
     u16 *pB = (*(u16 * *)&D_80182AF0);
     u16 *pC = (*(u16 * *)&D_80182AFC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801AB698;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801AB698 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801AB698 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80182AF8;
     extern u16 D_801AB698;
 
-    register s16 *pb0 __asm__("$9");   /* D_80182AF4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80182AF0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80182AFC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80182AF4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80182AF0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182AFC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80182AF0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182AFC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801AB688;
+    a1v = pac[0]; a2v = pac[2];
     D_801AB698 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801AB688)) {
     found:
         pb4 = (*(u16 * *)&D_80182AF8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80182AF0;
     extern u8 D_80182AF4;
     extern u8 D_80182AFC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80182AF4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80182AF0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182AFC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80182AF0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182AFC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801AB688;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801AB698 = 0;
+    ((H16 *)&D_801AB698)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80182AF8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_003/ov_SC05_003_jr_8015C32C.c b/src/ov_SC05_003/ov_SC05_003_jr_8015C32C.c
index 96b57b12ba..3936070900 100644
--- a/src/ov_SC05_003/ov_SC05_003_jr_8015C32C.c
+++ b/src/ov_SC05_003/ov_SC05_003_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80184BFC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80184BFC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_004/ov_SC05_004_after.c b/src/ov_SC05_004/ov_SC05_004_after.c
index ea46c2882c..af635f8ac2 100644
--- a/src/ov_SC05_004/ov_SC05_004_after.c
+++ b/src/ov_SC05_004/ov_SC05_004_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80183164[];
+    extern s32 (*D_80183164[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80183164[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80183164[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.c b/src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.c
index cc146e0838..d0b3958e0b 100644
--- a/src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.c
+++ b/src/ov_SC05_004/ov_SC05_004_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80181B04[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181A7C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80181ADC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80181A7C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181AE4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80181ADC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80181AE4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80181B04; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80181B04 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80181A4C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80181A4C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80181C00);
     u16 *pB = (*(u16 * *)&D_80181BFC);
     u16 *pC = (*(u16 * *)&D_80181C08);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019DD10;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019DD10 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019DD10 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80181C04;
     extern u16 D_8019DD10;
 
-    register s16 *pb0 __asm__("$9");   /* D_80181C00 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80181BFC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80181C08 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80181C00;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80181BFC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181C08); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80181BFC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181C08); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019DD00;
+    a1v = pac[0]; a2v = pac[2];
     D_8019DD10 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019DD00)) {
     found:
         pb4 = (*(u16 * *)&D_80181C04);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80181BFC;
     extern u8 D_80181C00;
     extern u8 D_80181C08;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80181C00);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80181BFC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80181C08); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80181BFC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80181C08); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019DD00;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_8019DD10 = 0;
+    ((H16 *)&D_8019DD10)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80181C04);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_004/ov_SC05_004_jr_8015C32C.c b/src/ov_SC05_004/ov_SC05_004_jr_8015C32C.c
index 17eb69eeee..8362d9f635 100644
--- a/src/ov_SC05_004/ov_SC05_004_jr_8015C32C.c
+++ b/src/ov_SC05_004/ov_SC05_004_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80183D08[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80183D08[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_005/ov_SC05_005_after.c b/src/ov_SC05_005/ov_SC05_005_after.c
index 304df4231d..e1c055968e 100644
--- a/src/ov_SC05_005/ov_SC05_005_after.c
+++ b/src/ov_SC05_005/ov_SC05_005_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80183F38[];
+    extern s32 (*D_80183F38[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80183F38[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80183F38[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.c b/src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.c
index ded44089b5..55b6becbf5 100644
--- a/src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.c
+++ b/src/ov_SC05_005/ov_SC05_005_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801828D8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182850; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801828B0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80182850 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801828B8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801828B0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801828B8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801828D8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801828D8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80182820;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80182820;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801829D4);
     u16 *pB = (*(u16 * *)&D_801829D0);
     u16 *pC = (*(u16 * *)&D_801829DC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B0978;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B0978 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B0978 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801829D8;
     extern u16 D_801B0978;
 
-    register s16 *pb0 __asm__("$9");   /* D_801829D4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_801829D0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_801829DC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801829D4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_801829D0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801829DC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801829D0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801829DC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B0968;
+    a1v = pac[0]; a2v = pac[2];
     D_801B0978 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B0968)) {
     found:
         pb4 = (*(u16 * *)&D_801829D8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801829D0;
     extern u8 D_801829D4;
     extern u8 D_801829DC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801829D4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801829D0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801829DC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801829D0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801829DC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B0968;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801B0978 = 0;
+    ((H16 *)&D_801B0978)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801829D8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_005/ov_SC05_005_jr_8015C32C.c b/src/ov_SC05_005/ov_SC05_005_jr_8015C32C.c
index 5127c27a4b..39e1a02702 100644
--- a/src/ov_SC05_005/ov_SC05_005_jr_8015C32C.c
+++ b/src/ov_SC05_005/ov_SC05_005_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80184ADC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80184ADC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_006/ov_SC05_006_after.c b/src/ov_SC05_006/ov_SC05_006_after.c
index 2e5567b364..f4d566d5b4 100644
--- a/src/ov_SC05_006/ov_SC05_006_after.c
+++ b/src/ov_SC05_006/ov_SC05_006_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80180F58[];
+    extern s32 (*D_80180F58[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80180F58[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80180F58[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.c b/src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.c
index fa47e1cfac..ad1c5e338d 100644
--- a/src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.c
+++ b/src/ov_SC05_006/ov_SC05_006_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017F8F8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F870; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017F8D0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017F870 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F8D8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017F8D0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017F8D8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F8F8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017F8F8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017F840;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017F840;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017F9F4);
     u16 *pB = (*(u16 * *)&D_8017F9F0);
     u16 *pC = (*(u16 * *)&D_8017F9FC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8018EAB0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8018EAB0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8018EAB0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017F9F8;
     extern u16 D_8018EAB0;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017F9F4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017F9F0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017F9FC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017F9F4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017F9F0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F9FC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017F9F0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F9FC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8018EAA0;
+    a1v = pac[0]; a2v = pac[2];
     D_8018EAB0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8018EAA0)) {
     found:
         pb4 = (*(u16 * *)&D_8017F9F8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017F9F0;
     extern u8 D_8017F9F4;
     extern u8 D_8017F9FC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017F9F4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017F9F0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F9FC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017F9F0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F9FC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8018EAA0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_8018EAB0 = 0;
+    ((H16 *)&D_8018EAB0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017F9F8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_006/ov_SC05_006_jr_8015C32C.c b/src/ov_SC05_006/ov_SC05_006_jr_8015C32C.c
index ef14ef0e48..d689e53efb 100644
--- a/src/ov_SC05_006/ov_SC05_006_jr_8015C32C.c
+++ b/src/ov_SC05_006/ov_SC05_006_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80181AFC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80181AFC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_007/ov_SC05_007_after.c b/src/ov_SC05_007/ov_SC05_007_after.c
index 0b7b4fafef..73f2163b5c 100644
--- a/src/ov_SC05_007/ov_SC05_007_after.c
+++ b/src/ov_SC05_007/ov_SC05_007_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80182554[];
+    extern s32 (*D_80182554[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80182554[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80182554[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.c b/src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.c
index 05414b0d85..dd8c333d79 100644
--- a/src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.c
+++ b/src/ov_SC05_007/ov_SC05_007_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80180EF4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180E6C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80180ECC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80180E6C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180ED4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80180ECC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80180ED4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180EF4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80180EF4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80180E3C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80180E3C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80180FF0);
     u16 *pB = (*(u16 * *)&D_80180FEC);
     u16 *pC = (*(u16 * *)&D_80180FF8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019BA90;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019BA90 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019BA90 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80180FF4;
     extern u16 D_8019BA90;
 
-    register s16 *pb0 __asm__("$9");   /* D_80180FF0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80180FEC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80180FF8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80180FF0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80180FEC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180FF8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80180FEC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80180FF8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019BA80;
+    a1v = pac[0]; a2v = pac[2];
     D_8019BA90 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019BA80)) {
     found:
         pb4 = (*(u16 * *)&D_80180FF4);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80180FEC;
     extern u8 D_80180FF0;
     extern u8 D_80180FF8;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80180FF0);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80180FEC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80180FF8); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80180FEC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80180FF8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019BA80;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_8019BA90 = 0;
+    ((H16 *)&D_8019BA90)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80180FF4);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_007/ov_SC05_007_jr_8015C32C.c b/src/ov_SC05_007/ov_SC05_007_jr_8015C32C.c
index 2ab9408bab..8cc1dc6ec9 100644
--- a/src/ov_SC05_007/ov_SC05_007_jr_8015C32C.c
+++ b/src/ov_SC05_007/ov_SC05_007_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801830F8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801830F8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_008/ov_SC05_008_after.c b/src/ov_SC05_008/ov_SC05_008_after.c
index 5269b478f3..4688a7814c 100644
--- a/src/ov_SC05_008/ov_SC05_008_after.c
+++ b/src/ov_SC05_008/ov_SC05_008_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801844AC[];
+    extern s32 (*D_801844AC[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801844AC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801844AC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.c b/src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.c
index 0f6e001b6d..3c1e3fc806 100644
--- a/src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.c
+++ b/src/ov_SC05_008/ov_SC05_008_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80182E4C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182DC4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80182E24;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80182DC4 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182E2C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80182E24;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80182E2C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182E4C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80182E4C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80182D94;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80182D94;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80182F48);
     u16 *pB = (*(u16 * *)&D_80182F44);
     u16 *pC = (*(u16 * *)&D_80182F50);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019FDC0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019FDC0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019FDC0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80182F4C;
     extern u16 D_8019FDC0;
 
-    register s16 *pb0 __asm__("$9");   /* D_80182F48 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80182F44 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80182F50 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80182F48;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80182F44; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182F50); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80182F44; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182F50); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019FDB0;
+    a1v = pac[0]; a2v = pac[2];
     D_8019FDC0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019FDB0)) {
     found:
         pb4 = (*(u16 * *)&D_80182F4C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80182F44;
     extern u8 D_80182F48;
     extern u8 D_80182F50;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80182F48);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80182F44); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182F50); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80182F44); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182F50); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019FDB0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_8019FDC0 = 0;
+    ((H16 *)&D_8019FDC0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80182F4C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_008/ov_SC05_008_jr_8015C32C.c b/src/ov_SC05_008/ov_SC05_008_jr_8015C32C.c
index cdabc9773d..10ad32b78f 100644
--- a/src/ov_SC05_008/ov_SC05_008_jr_8015C32C.c
+++ b/src/ov_SC05_008/ov_SC05_008_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80185050[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80185050[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.c b/src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.c
index 1dc25b2d30..0a6a3b0fa5 100644
--- a/src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.c
+++ b/src/ov_SC05_009/ov_SC05_009_jr_8012ACE0.c
@@ -1765,15 +1765,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017F058);
     u16 *pB = (*(u16 * *)&D_8017F054);
     u16 *pC = (*(u16 * *)&D_8017F060);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -1784,15 +1784,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -1805,10 +1805,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2187,57 +2187,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801957D0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801957D0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801957D0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2348,26 +2343,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017F05C;
     extern u16 D_801957D0;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017F058 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_8017F054 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_8017F060 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017F058;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017F054; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017F054; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801957C0;
+    a1v = pac[0]; a2v = pac[2];
     D_801957D0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801957C0)) {
     found:
         pb4 = (*(u16 * *)&D_8017F05C);
         ((u16 *)p2)[0] = pb4[0];
@@ -2413,23 +2407,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017F054;
     extern u8 D_8017F058;
     extern u8 D_8017F060;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017F058);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017F054); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017F054); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F060); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801957C0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801957D0 = 0;
+    ((H16 *)&D_801957D0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017F05C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_010/ov_SC05_010_after.c b/src/ov_SC05_010/ov_SC05_010_after.c
index 116479c16f..517e2b54e7 100644
--- a/src/ov_SC05_010/ov_SC05_010_after.c
+++ b/src/ov_SC05_010/ov_SC05_010_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018A498[];
+    extern s32 (*D_8018A498[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018A498[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018A498[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.c b/src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.c
index 0fe4928ad0..c065adb2d9 100644
--- a/src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.c
+++ b/src/ov_SC05_010/ov_SC05_010_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80188E38[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A tus1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188DB0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80188E10;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80188DB0 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188E18; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80188E10;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80188E18 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188E38; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A tus1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80188E38 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80188D80;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80188D80;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80188F34);
     u16 *pB = (*(u16 * *)&D_80188F30);
     u16 *pC = (*(u16 * *)&D_80188F3C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C5C20;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A tus1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A tus1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A tus1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A tus1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C5C20 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C5C20 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80188F38;
     extern u16 D_801C5C20;
 
-    register s16 *pb0 __asm__("$9");   /* D_80188F34 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pac __asm__("$6");   /* D_80188F30 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A tus1)
-    register s16 *pb8 __asm__("$8");   /* D_80188F3C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A tus1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80188F34;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
 
-    a = ((u16 *)p2)[0]; pac = D_80188F30; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80188F3C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80188F30; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80188F3C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801C5C10;
+    a1v = pac[0]; a2v = pac[2];
     D_801C5C20 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801C5C10)) {
     found:
         pb4 = (*(u16 * *)&D_80188F38);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80188F30;
     extern u8 D_80188F34;
     extern u8 D_80188F3C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80188F34);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80188F30); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80188F3C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80188F30); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80188F3C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801C5C10;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801C5C20 = 0;
+    ((H16 *)&D_801C5C20)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80188F38);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_010/ov_SC05_010_jr_8015C32C.c b/src/ov_SC05_010/ov_SC05_010_jr_8015C32C.c
index a0c5a79b76..48bf862c0c 100644
--- a/src/ov_SC05_010/ov_SC05_010_jr_8015C32C.c
+++ b/src/ov_SC05_010/ov_SC05_010_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018B03C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018B03C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_011/ov_SC05_011_after.c b/src/ov_SC05_011/ov_SC05_011_after.c
index 87acad4cce..d1bc734385 100644
--- a/src/ov_SC05_011/ov_SC05_011_after.c
+++ b/src/ov_SC05_011/ov_SC05_011_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8017F810[];
+    extern s32 (*D_8017F810[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8017F810[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8017F810[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.c b/src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.c
index fe550ac0b8..c8273234cd 100644
--- a/src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.c
+++ b/src/ov_SC05_011/ov_SC05_011_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017E1B0[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E128; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017E188;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017E128 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E190; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017E188;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017E190 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E1B0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017E1B0 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017E0F8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017E0F8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017E2AC);
     u16 *pB = (*(u16 * *)&D_8017E2A8);
     u16 *pC = (*(u16 * *)&D_8017E2B4);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019BDA8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019BDA8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019BDA8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017E2B0;
     extern u16 D_8019BDA8;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017E2AC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_8017E2A8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_8017E2B4 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017E2AC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_8017E2A8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E2B4); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017E2A8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E2B4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019BD98;
+    a1v = pac[0]; a2v = pac[2];
     D_8019BDA8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019BD98)) {
     found:
         pb4 = (*(u16 * *)&D_8017E2B0);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017E2A8;
     extern u8 D_8017E2AC;
     extern u8 D_8017E2B4;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017E2AC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017E2A8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E2B4); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017E2A8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E2B4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019BD98;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_8019BDA8 = 0;
+    ((H16 *)&D_8019BDA8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017E2B0);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_011/ov_SC05_011_jr_8015C32C.c b/src/ov_SC05_011/ov_SC05_011_jr_8015C32C.c
index 8e4e867653..d78425e93c 100644
--- a/src/ov_SC05_011/ov_SC05_011_jr_8015C32C.c
+++ b/src/ov_SC05_011/ov_SC05_011_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801803B4[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801803B4[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_017/ov_SC05_017_after.c b/src/ov_SC05_017/ov_SC05_017_after.c
index 3c59510087..6e600ac156 100644
--- a/src/ov_SC05_017/ov_SC05_017_after.c
+++ b/src/ov_SC05_017/ov_SC05_017_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018ECD0[];
+    extern s32 (*D_8018ECD0[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018ECD0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018ECD0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.c b/src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.c
index 7ca3f43a6b..32b0e84cb9 100644
--- a/src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.c
+++ b/src/ov_SC05_017/ov_SC05_017_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018D670[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D5E8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018D648;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018D5E8 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D650; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018D648;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018D650 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D670; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018D670 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018D5B8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018D5B8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018D76C);
     u16 *pB = (*(u16 * *)&D_8018D768);
     u16 *pC = (*(u16 * *)&D_8018D774);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801EB8E8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801EB8E8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801EB8E8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018D770;
     extern u16 D_801EB8E8;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018D76C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_8018D768 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_8018D774 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018D76C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_8018D768; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018D774); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018D768; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018D774); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801EB8D8;
+    a1v = pac[0]; a2v = pac[2];
     D_801EB8E8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801EB8D8)) {
     found:
         pb4 = (*(u16 * *)&D_8018D770);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018D768;
     extern u8 D_8018D76C;
     extern u8 D_8018D774;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018D76C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018D768); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018D774); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018D768); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018D774); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801EB8D8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801EB8E8 = 0;
+    ((H16 *)&D_801EB8E8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018D770);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_017/ov_SC05_017_jr_8015C32C.c b/src/ov_SC05_017/ov_SC05_017_jr_8015C32C.c
index 875330ffe3..d9a2ece5ab 100644
--- a/src/ov_SC05_017/ov_SC05_017_jr_8015C32C.c
+++ b/src/ov_SC05_017/ov_SC05_017_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018F874[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018F874[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC05_018/ov_SC05_018_after.c b/src/ov_SC05_018/ov_SC05_018_after.c
index ee6119d96a..0ef8e7e9b2 100644
--- a/src/ov_SC05_018/ov_SC05_018_after.c
+++ b/src/ov_SC05_018/ov_SC05_018_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018842C[];
+    extern s32 (*D_8018842C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018842C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018842C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.c b/src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.c
index 775ec7bb3f..300c75b9c7 100644
--- a/src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.c
+++ b/src/ov_SC05_018/ov_SC05_018_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80186DCC[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186D44; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80186DA4;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80186D44 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186DAC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80186DA4;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80186DAC + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186DCC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80186DCC + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80186D14;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80186D14;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80186EC8);
     u16 *pB = (*(u16 * *)&D_80186EC4);
     u16 *pC = (*(u16 * *)&D_80186ED0);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801E5028;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801E5028 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801E5028 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80186ECC;
     extern u16 D_801E5028;
 
-    register s16 *pb0 __asm__("$9");   /* D_80186EC8 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_80186EC4 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_80186ED0 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80186EC8;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_80186EC4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186ED0); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80186EC4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186ED0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801E5018;
+    a1v = pac[0]; a2v = pac[2];
     D_801E5028 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801E5018)) {
     found:
         pb4 = (*(u16 * *)&D_80186ECC);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80186EC4;
     extern u8 D_80186EC8;
     extern u8 D_80186ED0;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80186EC8);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80186EC4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186ED0); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80186EC4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186ED0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801E5018;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801E5028 = 0;
+    ((H16 *)&D_801E5028)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80186ECC);
         p2[0] = pb4[0];
diff --git a/src/ov_SC05_018/ov_SC05_018_jr_8015C32C.c b/src/ov_SC05_018/ov_SC05_018_jr_8015C32C.c
index 9708635198..0e18f19def 100644
--- a/src/ov_SC05_018/ov_SC05_018_jr_8015C32C.c
+++ b/src/ov_SC05_018/ov_SC05_018_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80188FD0[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80188FD0[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_000/ov_SC06_000_after.c b/src/ov_SC06_000/ov_SC06_000_after.c
index 1f5e4cd77b..b331c198aa 100644
--- a/src/ov_SC06_000/ov_SC06_000_after.c
+++ b/src/ov_SC06_000/ov_SC06_000_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80189D80[];
+    extern s32 (*D_80189D80[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80189D80[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80189D80[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.c b/src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.c
index 96223e4591..bb0a21d6bc 100644
--- a/src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.c
+++ b/src/ov_SC06_000/ov_SC06_000_jr_8012ACE0.c
@@ -1126,156 +1126,136 @@ extern s16 D_80188720[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188698; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801886F8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80188698 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188700; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801886F8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80188700 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80188720; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80188720 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80188668;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80188668;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2309,15 +2289,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018881C);
     u16 *pB = (*(u16 * *)&D_80188818);
     u16 *pC = (*(u16 * *)&D_80188824);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2328,15 +2308,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2349,10 +2329,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2780,57 +2760,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801AD368;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801AD368 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801AD368 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2941,26 +2916,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80188820;
     extern u16 D_801AD368;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018881C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_80188818 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_80188824 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018881C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_80188818; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80188824); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80188818; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80188824); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801AD358;
+    a1v = pac[0]; a2v = pac[2];
     D_801AD368 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801AD358)) {
     found:
         pb4 = (*(u16 * *)&D_80188820);
         ((u16 *)p2)[0] = pb4[0];
@@ -3006,23 +2980,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80188818;
     extern u8 D_8018881C;
     extern u8 D_80188824;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018881C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80188818); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80188824); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80188818); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80188824); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801AD358;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801AD368 = 0;
+    ((H16 *)&D_801AD368)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80188820);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_000/ov_SC06_000_jr_8015C32C.c b/src/ov_SC06_000/ov_SC06_000_jr_8015C32C.c
index 29d0955a51..0a27aec781 100644
--- a/src/ov_SC06_000/ov_SC06_000_jr_8015C32C.c
+++ b/src/ov_SC06_000/ov_SC06_000_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018A924[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018A924[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_006/ov_SC06_006_after.c b/src/ov_SC06_006/ov_SC06_006_after.c
index 0c99f5cb47..ad6a567c64 100644
--- a/src/ov_SC06_006/ov_SC06_006_after.c
+++ b/src/ov_SC06_006/ov_SC06_006_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801838A4[];
+    extern s32 (*D_801838A4[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801838A4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801838A4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.c b/src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.c
index f9c6d61664..eb3f18db44 100644
--- a/src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.c
+++ b/src/ov_SC06_006/ov_SC06_006_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80182244[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801821BC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018221C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801821BC + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182224; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018221C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80182224 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182244; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80182244 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018218C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018218C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80182340);
     u16 *pB = (*(u16 * *)&D_8018233C);
     u16 *pC = (*(u16 * *)&D_80182348);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801F6DB0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801F6DB0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801F6DB0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80182344;
     extern u16 D_801F6DB0;
 
-    register s16 *pb0 __asm__("$9");   /* D_80182340 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_8018233C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_80182348 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80182340;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_8018233C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182348); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018233C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182348); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801F6DA0;
+    a1v = pac[0]; a2v = pac[2];
     D_801F6DB0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801F6DA0)) {
     found:
         pb4 = (*(u16 * *)&D_80182344);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018233C;
     extern u8 D_80182340;
     extern u8 D_80182348;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80182340);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018233C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182348); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018233C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182348); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801F6DA0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801F6DB0 = 0;
+    ((H16 *)&D_801F6DB0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80182344);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_006/ov_SC06_006_jr_8015C32C.c b/src/ov_SC06_006/ov_SC06_006_jr_8015C32C.c
index 189845fe3f..4ab1f86913 100644
--- a/src/ov_SC06_006/ov_SC06_006_jr_8015C32C.c
+++ b/src/ov_SC06_006/ov_SC06_006_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80184448[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80184448[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_008/ov_SC06_008_after.c b/src/ov_SC06_008/ov_SC06_008_after.c
index d788657b1e..e2d00e0608 100644
--- a/src/ov_SC06_008/ov_SC06_008_after.c
+++ b/src/ov_SC06_008/ov_SC06_008_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018730C[];
+    extern s32 (*D_8018730C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018730C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018730C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.c b/src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.c
index cc6f78e22b..608cde9322 100644
--- a/src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.c
+++ b/src/ov_SC06_008/ov_SC06_008_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80185CAC[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185C24; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80185C84;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80185C24 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185C8C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80185C84;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80185C8C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185CAC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80185CAC + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80185BF4;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80185BF4;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80185DA8);
     u16 *pB = (*(u16 * *)&D_80185DA4);
     u16 *pC = (*(u16 * *)&D_80185DB0);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A8D30;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A8D30 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A8D30 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80185DAC;
     extern u16 D_801A8D30;
 
-    register s16 *pb0 __asm__("$9");   /* D_80185DA8 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_80185DA4 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_80185DB0 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80185DA8;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_80185DA4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185DB0); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80185DA4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185DB0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A8D20;
+    a1v = pac[0]; a2v = pac[2];
     D_801A8D30 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A8D20)) {
     found:
         pb4 = (*(u16 * *)&D_80185DAC);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80185DA4;
     extern u8 D_80185DA8;
     extern u8 D_80185DB0;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80185DA8);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80185DA4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80185DB0); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80185DA4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80185DB0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A8D20;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801A8D30 = 0;
+    ((H16 *)&D_801A8D30)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80185DAC);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_008/ov_SC06_008_jr_8015C32C.c b/src/ov_SC06_008/ov_SC06_008_jr_8015C32C.c
index 0c4b34c5ea..87845eb2c4 100644
--- a/src/ov_SC06_008/ov_SC06_008_jr_8015C32C.c
+++ b/src/ov_SC06_008/ov_SC06_008_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80187EB0[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80187EB0[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_010/ov_SC06_010_after.c b/src/ov_SC06_010/ov_SC06_010_after.c
index 38c3a68158..ae4938a0e1 100644
--- a/src/ov_SC06_010/ov_SC06_010_after.c
+++ b/src/ov_SC06_010/ov_SC06_010_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801884E8[];
+    extern s32 (*D_801884E8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801884E8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801884E8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.c b/src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.c
index 8eb3c9bc9f..0be1062359 100644
--- a/src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.c
+++ b/src/ov_SC06_010/ov_SC06_010_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80186E88[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186E00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80186E60;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80186E00 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186E68; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80186E60;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80186E68 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186E88; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80186E88 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80186DD0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80186DD0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80186F84);
     u16 *pB = (*(u16 * *)&D_80186F80);
     u16 *pC = (*(u16 * *)&D_80186F8C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B0D68;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B0D68 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B0D68 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80186F88;
     extern u16 D_801B0D68;
 
-    register s16 *pb0 __asm__("$9");   /* D_80186F84 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_80186F80 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_80186F8C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80186F84;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_80186F80; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186F8C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80186F80; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186F8C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B0D58;
+    a1v = pac[0]; a2v = pac[2];
     D_801B0D68 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B0D58)) {
     found:
         pb4 = (*(u16 * *)&D_80186F88);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80186F80;
     extern u8 D_80186F84;
     extern u8 D_80186F8C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80186F84);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80186F80); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186F8C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80186F80); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186F8C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B0D58;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801B0D68 = 0;
+    ((H16 *)&D_801B0D68)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80186F88);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_010/ov_SC06_010_jr_8015C32C.c b/src/ov_SC06_010/ov_SC06_010_jr_8015C32C.c
index 3364aac851..8bf6d72842 100644
--- a/src/ov_SC06_010/ov_SC06_010_jr_8015C32C.c
+++ b/src/ov_SC06_010/ov_SC06_010_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018908C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018908C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_011/ov_SC06_011_after.c b/src/ov_SC06_011/ov_SC06_011_after.c
index d801a0a1be..8840a00b75 100644
--- a/src/ov_SC06_011/ov_SC06_011_after.c
+++ b/src/ov_SC06_011/ov_SC06_011_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80181F48[];
+    extern s32 (*D_80181F48[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80181F48[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80181F48[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.c b/src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.c
index c23e94a821..cc97782b9b 100644
--- a/src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.c
+++ b/src/ov_SC06_011/ov_SC06_011_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801808E8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180860; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801808C0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80180860 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801808C8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801808C0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801808C8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801808E8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801808E8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80180830;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80180830;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801809E4);
     u16 *pB = (*(u16 * *)&D_801809E0);
     u16 *pC = (*(u16 * *)&D_801809EC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801AA918;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801AA918 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801AA918 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801809E8;
     extern u16 D_801AA918;
 
-    register s16 *pb0 __asm__("$9");   /* D_801809E4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_801809E0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_801809EC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801809E4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_801809E0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801809EC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801809E0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801809EC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801AA908;
+    a1v = pac[0]; a2v = pac[2];
     D_801AA918 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801AA908)) {
     found:
         pb4 = (*(u16 * *)&D_801809E8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801809E0;
     extern u8 D_801809E4;
     extern u8 D_801809EC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801809E4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801809E0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801809EC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801809E0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801809EC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801AA908;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801AA918 = 0;
+    ((H16 *)&D_801AA918)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801809E8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_011/ov_SC06_011_jr_8015C32C.c b/src/ov_SC06_011/ov_SC06_011_jr_8015C32C.c
index 9e3c45f0ce..d3cd93d01a 100644
--- a/src/ov_SC06_011/ov_SC06_011_jr_8015C32C.c
+++ b/src/ov_SC06_011/ov_SC06_011_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80182AEC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80182AEC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_013/ov_SC06_013_after.c b/src/ov_SC06_013/ov_SC06_013_after.c
index 32b4bdc612..78294d8775 100644
--- a/src/ov_SC06_013/ov_SC06_013_after.c
+++ b/src/ov_SC06_013/ov_SC06_013_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801806C4[];
+    extern s32 (*D_801806C4[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801806C4[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801806C4[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.c b/src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.c
index b2db5b0380..3a3b9ceeac 100644
--- a/src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.c
+++ b/src/ov_SC06_013/ov_SC06_013_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017F064[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EFDC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017F03C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017EFDC + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F044; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017F03C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017F044 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F064; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017F064 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017EFAC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017EFAC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017F160);
     u16 *pB = (*(u16 * *)&D_8017F15C);
     u16 *pC = (*(u16 * *)&D_8017F168);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801997D0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801997D0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801997D0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017F164;
     extern u16 D_801997D0;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017F160 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_8017F15C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_8017F168 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017F160;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_8017F15C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F168); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017F15C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F168); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801997C0;
+    a1v = pac[0]; a2v = pac[2];
     D_801997D0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801997C0)) {
     found:
         pb4 = (*(u16 * *)&D_8017F164);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017F15C;
     extern u8 D_8017F160;
     extern u8 D_8017F168;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017F160);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017F15C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F168); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017F15C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F168); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801997C0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801997D0 = 0;
+    ((H16 *)&D_801997D0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017F164);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_013/ov_SC06_013_jr_8015C32C.c b/src/ov_SC06_013/ov_SC06_013_jr_8015C32C.c
index 7b148a2140..0a78b3b6ab 100644
--- a/src/ov_SC06_013/ov_SC06_013_jr_8015C32C.c
+++ b/src/ov_SC06_013/ov_SC06_013_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80181268[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80181268[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_014/ov_SC06_014_after.c b/src/ov_SC06_014/ov_SC06_014_after.c
index c691771668..47ecedaf70 100644
--- a/src/ov_SC06_014/ov_SC06_014_after.c
+++ b/src/ov_SC06_014/ov_SC06_014_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80181A28[];
+    extern s32 (*D_80181A28[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80181A28[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80181A28[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.c b/src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.c
index 7f8b044eb7..10de12674c 100644
--- a/src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.c
+++ b/src/ov_SC06_014/ov_SC06_014_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801803C8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80180340; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801803A0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80180340 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801803A8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801803A0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801803A8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801803C8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801803C8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80180310;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80180310;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801804C4);
     u16 *pB = (*(u16 * *)&D_801804C0);
     u16 *pC = (*(u16 * *)&D_801804CC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A01C0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A01C0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A01C0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801804C8;
     extern u16 D_801A01C0;
 
-    register s16 *pb0 __asm__("$9");   /* D_801804C4 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_801804C0 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_801804CC -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801804C4;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_801804C0; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801804CC); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801804C0; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801804CC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A01B0;
+    a1v = pac[0]; a2v = pac[2];
     D_801A01C0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A01B0)) {
     found:
         pb4 = (*(u16 * *)&D_801804C8);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801804C0;
     extern u8 D_801804C4;
     extern u8 D_801804CC;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801804C4);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801804C0); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801804CC); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801804C0); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801804CC); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A01B0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801A01C0 = 0;
+    ((H16 *)&D_801A01C0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801804C8);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_014/ov_SC06_014_jr_8015C32C.c b/src/ov_SC06_014/ov_SC06_014_jr_8015C32C.c
index 087d831080..2e79893001 100644
--- a/src/ov_SC06_014/ov_SC06_014_jr_8015C32C.c
+++ b/src/ov_SC06_014/ov_SC06_014_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801825CC[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801825CC[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_015/ov_SC06_015_after.c b/src/ov_SC06_015/ov_SC06_015_after.c
index f3d19a1ecd..7d195875e8 100644
--- a/src/ov_SC06_015/ov_SC06_015_after.c
+++ b/src/ov_SC06_015/ov_SC06_015_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80180580[];
+    extern s32 (*D_80180580[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80180580[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80180580[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.c b/src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.c
index db016ad4f7..15faf68991 100644
--- a/src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.c
+++ b/src/ov_SC06_015/ov_SC06_015_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017EF20[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EE98; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017EEF8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017EE98 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017EEF8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017EF00 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF20; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017EF20 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017EE68;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017EE68;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017F01C);
     u16 *pB = (*(u16 * *)&D_8017F018);
     u16 *pC = (*(u16 * *)&D_8017F024);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801935A0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801935A0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801935A0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017F020;
     extern u16 D_801935A0;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017F01C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_8017F018 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_8017F024 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017F01C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_8017F018; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F024); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017F018; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F024); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80193590;
+    a1v = pac[0]; a2v = pac[2];
     D_801935A0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80193590)) {
     found:
         pb4 = (*(u16 * *)&D_8017F020);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017F018;
     extern u8 D_8017F01C;
     extern u8 D_8017F024;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017F01C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017F018); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F024); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017F018); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F024); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80193590;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801935A0 = 0;
+    ((H16 *)&D_801935A0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017F020);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_015/ov_SC06_015_jr_8015C32C.c b/src/ov_SC06_015/ov_SC06_015_jr_8015C32C.c
index 27a0b795bf..289831b65c 100644
--- a/src/ov_SC06_015/ov_SC06_015_jr_8015C32C.c
+++ b/src/ov_SC06_015/ov_SC06_015_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80181124[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80181124[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_016/ov_SC06_016_after.c b/src/ov_SC06_016/ov_SC06_016_after.c
index 6a33424466..330ea1ab4c 100644
--- a/src/ov_SC06_016/ov_SC06_016_after.c
+++ b/src/ov_SC06_016/ov_SC06_016_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80186990[];
+    extern s32 (*D_80186990[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80186990[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80186990[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.c b/src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.c
index e9557b7ac7..e2e4bcbcfa 100644
--- a/src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.c
+++ b/src/ov_SC06_016/ov_SC06_016_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80185330[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801852A8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80185308;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801852A8 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185310; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80185308;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80185310 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80185330; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80185330 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80185278;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80185278;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018542C);
     u16 *pB = (*(u16 * *)&D_80185428);
     u16 *pC = (*(u16 * *)&D_80185434);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019E370;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019E370 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019E370 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80185430;
     extern u16 D_8019E370;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018542C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_80185428 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_80185434 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018542C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_80185428; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185434); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80185428; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185434); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019E360;
+    a1v = pac[0]; a2v = pac[2];
     D_8019E370 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019E360)) {
     found:
         pb4 = (*(u16 * *)&D_80185430);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80185428;
     extern u8 D_8018542C;
     extern u8 D_80185434;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018542C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80185428); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80185434); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80185428); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80185434); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019E360;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_8019E370 = 0;
+    ((H16 *)&D_8019E370)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80185430);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_016/ov_SC06_016_jr_8015C32C.c b/src/ov_SC06_016/ov_SC06_016_jr_8015C32C.c
index dbfeff7a32..a5acab75ac 100644
--- a/src/ov_SC06_016/ov_SC06_016_jr_8015C32C.c
+++ b/src/ov_SC06_016/ov_SC06_016_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80187534[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80187534[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_018/ov_SC06_018_after.c b/src/ov_SC06_018/ov_SC06_018_after.c
index 86b995e0a6..afd4180ec7 100644
--- a/src/ov_SC06_018/ov_SC06_018_after.c
+++ b/src/ov_SC06_018/ov_SC06_018_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801950CC[];
+    extern s32 (*D_801950CC[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801950CC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801950CC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.c b/src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.c
index ff331b19ba..7fb9b18ec0 100644
--- a/src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.c
+++ b/src/ov_SC06_018/ov_SC06_018_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80193A6C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801939E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80193A44;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801939E4 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80193A4C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80193A44;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80193A4C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80193A6C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80193A6C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801939B4;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801939B4;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2310,15 +2290,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80193B68);
     u16 *pB = (*(u16 * *)&D_80193B64);
     u16 *pC = (*(u16 * *)&D_80193B70);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2329,15 +2309,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2350,10 +2330,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2781,57 +2761,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801D3C58;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801D3C58 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801D3C58 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2942,26 +2917,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80193B6C;
     extern u16 D_801D3C58;
 
-    register s16 *pb0 __asm__("$9");   /* D_80193B68 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_80193B64 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_80193B70 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80193B68;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_80193B64; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80193B70); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80193B64; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80193B70); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801D3C48;
+    a1v = pac[0]; a2v = pac[2];
     D_801D3C58 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801D3C48)) {
     found:
         pb4 = (*(u16 * *)&D_80193B6C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3003,27 +2977,25 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
 {
     /* [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. */
+       Declaration-only move (cookbook §100); the whole-binary byte-gate is the arbiter. */
     extern u8 D_80193B64;
     extern u8 D_80193B68;
     extern u8 D_80193B70;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80193B68);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80193B64); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80193B70); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80193B64); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80193B70); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801D3C48;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801D3C58 = 0;
+    ((H16 *)&D_801D3C58)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80193B6C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_018/ov_SC06_018_jr_8015C32C.c b/src/ov_SC06_018/ov_SC06_018_jr_8015C32C.c
index d6a5acf98c..0583e9c706 100644
--- a/src/ov_SC06_018/ov_SC06_018_jr_8015C32C.c
+++ b/src/ov_SC06_018/ov_SC06_018_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80195C70[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80195C70[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_020/ov_SC06_020_after.c b/src/ov_SC06_020/ov_SC06_020_after.c
index cbff60e2b9..5de78f9aa3 100644
--- a/src/ov_SC06_020/ov_SC06_020_after.c
+++ b/src/ov_SC06_020/ov_SC06_020_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80186B54[];
+    extern s32 (*D_80186B54[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80186B54[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80186B54[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.c b/src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.c
index 4275361423..7d794b75f0 100644
--- a/src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.c
+++ b/src/ov_SC06_020/ov_SC06_020_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801854F4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018546C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801854CC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018546C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801854D4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801854CC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801854D4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801854F4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801854F4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018543C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018543C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801855F0);
     u16 *pB = (*(u16 * *)&D_801855EC);
     u16 *pC = (*(u16 * *)&D_801855F8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B9470;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B9470 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B9470 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801855F4;
     extern u16 D_801B9470;
 
-    register s16 *pb0 __asm__("$9");   /* D_801855F0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_801855EC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_801855F8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801855F0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_801855EC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801855F8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801855EC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801855F8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B9460;
+    a1v = pac[0]; a2v = pac[2];
     D_801B9470 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B9460)) {
     found:
         pb4 = (*(u16 * *)&D_801855F4);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801855EC;
     extern u8 D_801855F0;
     extern u8 D_801855F8;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801855F0);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801855EC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801855F8); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801855EC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801855F8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B9460;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801B9470 = 0;
+    ((H16 *)&D_801B9470)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801855F4);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_020/ov_SC06_020_jr_8015C32C.c b/src/ov_SC06_020/ov_SC06_020_jr_8015C32C.c
index 12de9ba1d7..28833065c4 100644
--- a/src/ov_SC06_020/ov_SC06_020_jr_8015C32C.c
+++ b/src/ov_SC06_020/ov_SC06_020_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801876F8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus3)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801876F8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_022/ov_SC06_022_after.c b/src/ov_SC06_022/ov_SC06_022_after.c
index 6b8aa6261b..348993ed2f 100644
--- a/src/ov_SC06_022/ov_SC06_022_after.c
+++ b/src/ov_SC06_022/ov_SC06_022_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018EE10[];
+    extern s32 (*D_8018EE10[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018EE10[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018EE10[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.c b/src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.c
index 4ed6e122fe..073151e45e 100644
--- a/src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.c
+++ b/src/ov_SC06_022/ov_SC06_022_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018D7B0[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus3)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D728; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018D788;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018D728 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D790; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018D788;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018D790 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018D7B0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus3)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018D7B0 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018D6F8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018D6F8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018D8AC);
     u16 *pB = (*(u16 * *)&D_8018D8A8);
     u16 *pC = (*(u16 * *)&D_8018D8B4);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801E0CD8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus3)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus3)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus3)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus3)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801E0CD8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801E0CD8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018D8B0;
     extern u16 D_801E0CD8;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018D8AC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");   /* D_8018D8A8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$8");   /* D_8018D8B4 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018D8AC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = ((u16 *)p2)[0]; pac = D_8018D8A8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018D8B4); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018D8A8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018D8B4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801E0CC8;
+    a1v = pac[0]; a2v = pac[2];
     D_801E0CD8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801E0CC8)) {
     found:
         pb4 = (*(u16 * *)&D_8018D8B0);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018D8A8;
     extern u8 D_8018D8AC;
     extern u8 D_8018D8B4;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus3)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus3)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018D8AC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus3)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018D8A8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018D8B4); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018D8A8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018D8B4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801E0CC8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus3)
-    D_801E0CD8 = 0;
+    ((H16 *)&D_801E0CD8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018D8B0);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_022/ov_SC06_022_jr_8015C32C.c b/src/ov_SC06_022/ov_SC06_022_jr_8015C32C.c
index 35274ff462..b2ce96aca1 100644
--- a/src/ov_SC06_022/ov_SC06_022_jr_8015C32C.c
+++ b/src/ov_SC06_022/ov_SC06_022_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018F9B4[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018F9B4[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_024/ov_SC06_024_after.c b/src/ov_SC06_024/ov_SC06_024_after.c
index d5f8f85004..f679622441 100644
--- a/src/ov_SC06_024/ov_SC06_024_after.c
+++ b/src/ov_SC06_024/ov_SC06_024_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801912E8[];
+    extern s32 (*D_801912E8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801912E8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801912E8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.c b/src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.c
index a7d758e698..23f61f9a34 100644
--- a/src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.c
+++ b/src/ov_SC06_024/ov_SC06_024_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018FC88[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus4)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018FC00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018FC60;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018FC00 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018FC68; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018FC60;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018FC68 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018FC88; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018FC88 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018FBD0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018FBD0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018FD84);
     u16 *pB = (*(u16 * *)&D_8018FD80);
     u16 *pC = (*(u16 * *)&D_8018FD8C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801DFE58;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801DFE58 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801DFE58 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018FD88;
     extern u16 D_801DFE58;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018FD84 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");   /* D_8018FD80 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$8");   /* D_8018FD8C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018FD84;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = ((u16 *)p2)[0]; pac = D_8018FD80; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018FD8C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018FD80; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018FD8C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801DFE48;
+    a1v = pac[0]; a2v = pac[2];
     D_801DFE58 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801DFE48)) {
     found:
         pb4 = (*(u16 * *)&D_8018FD88);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018FD80;
     extern u8 D_8018FD84;
     extern u8 D_8018FD8C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018FD84);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018FD80); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018FD8C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018FD80); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018FD8C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801DFE48;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-    D_801DFE58 = 0;
+    ((H16 *)&D_801DFE58)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018FD88);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_024/ov_SC06_024_jr_8015C32C.c b/src/ov_SC06_024/ov_SC06_024_jr_8015C32C.c
index b426304067..18b63f6612 100644
--- a/src/ov_SC06_024/ov_SC06_024_jr_8015C32C.c
+++ b/src/ov_SC06_024/ov_SC06_024_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80191E8C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80191E8C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_025/ov_SC06_025_after.c b/src/ov_SC06_025/ov_SC06_025_after.c
index 5eeed64413..02cf544830 100644
--- a/src/ov_SC06_025/ov_SC06_025_after.c
+++ b/src/ov_SC06_025/ov_SC06_025_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018678C[];
+    extern s32 (*D_8018678C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus4)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus4)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018678C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018678C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus4)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.c b/src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.c
index 0e4c92897c..c4f0e00699 100644
--- a/src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.c
+++ b/src/ov_SC06_025/ov_SC06_025_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018512C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus4)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801850A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80185104;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801850A4 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018510C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80185104;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018510C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018512C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018512C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80185074;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80185074;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80185228);
     u16 *pB = (*(u16 * *)&D_80185224);
     u16 *pC = (*(u16 * *)&D_80185230);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B0020;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B0020 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B0020 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018522C;
     extern u16 D_801B0020;
 
-    register s16 *pb0 __asm__("$9");   /* D_80185228 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");   /* D_80185224 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$8");   /* D_80185230 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80185228;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = ((u16 *)p2)[0]; pac = D_80185224; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185230); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80185224; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80185230); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B0010;
+    a1v = pac[0]; a2v = pac[2];
     D_801B0020 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B0010)) {
     found:
         pb4 = (*(u16 * *)&D_8018522C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80185224;
     extern u8 D_80185228;
     extern u8 D_80185230;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80185228);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80185224); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80185230); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80185224); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80185230); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B0010;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-    D_801B0020 = 0;
+    ((H16 *)&D_801B0020)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018522C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_025/ov_SC06_025_jr_8015C32C.c b/src/ov_SC06_025/ov_SC06_025_jr_8015C32C.c
index 55a3db3228..463101cea2 100644
--- a/src/ov_SC06_025/ov_SC06_025_jr_8015C32C.c
+++ b/src/ov_SC06_025/ov_SC06_025_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80187330[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80187330[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_027/ov_SC06_027_after.c b/src/ov_SC06_027/ov_SC06_027_after.c
index 2b30594a31..9459eb24fc 100644
--- a/src/ov_SC06_027/ov_SC06_027_after.c
+++ b/src/ov_SC06_027/ov_SC06_027_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8017FACC[];
+    extern s32 (*D_8017FACC[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus5)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus5)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8017FACC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8017FACC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus5)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus5)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.c b/src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.c
index 1c6ad5485b..c37b51c51a 100644
--- a/src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.c
+++ b/src/ov_SC06_027/ov_SC06_027_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017E46C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus4)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E3E4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017E444;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017E3E4 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E44C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017E444;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017E44C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E46C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017E46C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017E3B4;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017E3B4;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017E568);
     u16 *pB = (*(u16 * *)&D_8017E564);
     u16 *pC = (*(u16 * *)&D_8017E570);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019BFF8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019BFF8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019BFF8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017E56C;
     extern u16 D_8019BFF8;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017E568 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");   /* D_8017E564 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$8");   /* D_8017E570 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017E568;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = ((u16 *)p2)[0]; pac = D_8017E564; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E570); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017E564; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E570); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019BFE8;
+    a1v = pac[0]; a2v = pac[2];
     D_8019BFF8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019BFE8)) {
     found:
         pb4 = (*(u16 * *)&D_8017E56C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017E564;
     extern u8 D_8017E568;
     extern u8 D_8017E570;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017E568);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017E564); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E570); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017E564); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E570); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019BFE8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-    D_8019BFF8 = 0;
+    ((H16 *)&D_8019BFF8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017E56C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_027/ov_SC06_027_jr_8015C32C.c b/src/ov_SC06_027/ov_SC06_027_jr_8015C32C.c
index df80123f7a..3e2570c805 100644
--- a/src/ov_SC06_027/ov_SC06_027_jr_8015C32C.c
+++ b/src/ov_SC06_027/ov_SC06_027_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80180670[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80180670[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_029/ov_SC06_029_after.c b/src/ov_SC06_029/ov_SC06_029_after.c
index 70fe7d7ff9..35a793d549 100644
--- a/src/ov_SC06_029/ov_SC06_029_after.c
+++ b/src/ov_SC06_029/ov_SC06_029_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018E060[];
+    extern s32 (*D_8018E060[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus5)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus5)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018E060[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018E060[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus5)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus5)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.c b/src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.c
index a1fb1a7529..38d1be5318 100644
--- a/src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.c
+++ b/src/ov_SC06_029/ov_SC06_029_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8018CA00[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus4)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018C978; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018C9D8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018C978 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018C9E0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018C9D8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018C9E0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018CA00; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018CA00 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018C948;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018C948;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018CAFC);
     u16 *pB = (*(u16 * *)&D_8018CAF8);
     u16 *pC = (*(u16 * *)&D_8018CB04);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801DB918;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801DB918 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801DB918 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8018CB00;
     extern u16 D_801DB918;
 
-    register s16 *pb0 __asm__("$9");   /* D_8018CAFC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");   /* D_8018CAF8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$8");   /* D_8018CB04 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8018CAFC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = ((u16 *)p2)[0]; pac = D_8018CAF8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018CB04); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8018CAF8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8018CB04); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801DB908;
+    a1v = pac[0]; a2v = pac[2];
     D_801DB918 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801DB908)) {
     found:
         pb4 = (*(u16 * *)&D_8018CB00);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8018CAF8;
     extern u8 D_8018CAFC;
     extern u8 D_8018CB04;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8018CAFC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8018CAF8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8018CB04); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8018CAF8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8018CB04); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801DB908;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-    D_801DB918 = 0;
+    ((H16 *)&D_801DB918)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8018CB00);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_029/ov_SC06_029_jr_8015C32C.c b/src/ov_SC06_029/ov_SC06_029_jr_8015C32C.c
index 3b1f4a5380..9a96606459 100644
--- a/src/ov_SC06_029/ov_SC06_029_jr_8015C32C.c
+++ b/src/ov_SC06_029/ov_SC06_029_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8018EC04[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8018EC04[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_030/ov_SC06_030_after.c b/src/ov_SC06_030/ov_SC06_030_after.c
index 9d438c5fc7..b2e49db308 100644
--- a/src/ov_SC06_030/ov_SC06_030_after.c
+++ b/src/ov_SC06_030/ov_SC06_030_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80183950[];
+    extern s32 (*D_80183950[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus5)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus5)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80183950[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80183950[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus5)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus5)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.c b/src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.c
index 4e144cb223..fcb43b82e6 100644
--- a/src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.c
+++ b/src/ov_SC06_030/ov_SC06_030_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801822F0[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus4)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182268; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801822C8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80182268 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801822D0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801822C8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801822D0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801822F0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801822F0 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80182238;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80182238;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801823EC);
     u16 *pB = (*(u16 * *)&D_801823E8);
     u16 *pC = (*(u16 * *)&D_801823F4);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801B8B78;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801B8B78 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801B8B78 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801823F0;
     extern u16 D_801B8B78;
 
-    register s16 *pb0 __asm__("$9");   /* D_801823EC -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");   /* D_801823E8 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$8");   /* D_801823F4 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801823EC;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = ((u16 *)p2)[0]; pac = D_801823E8; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801823F4); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801823E8; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801823F4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801B8B68;
+    a1v = pac[0]; a2v = pac[2];
     D_801B8B78 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801B8B68)) {
     found:
         pb4 = (*(u16 * *)&D_801823F0);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801823E8;
     extern u8 D_801823EC;
     extern u8 D_801823F4;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801823EC);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801823E8); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801823F4); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801823E8); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801823F4); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801B8B68;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-    D_801B8B78 = 0;
+    ((H16 *)&D_801B8B78)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801823F0);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_030/ov_SC06_030_jr_8015C32C.c b/src/ov_SC06_030/ov_SC06_030_jr_8015C32C.c
index 9c83998c35..4e3d8567f4 100644
--- a/src/ov_SC06_030/ov_SC06_030_jr_8015C32C.c
+++ b/src/ov_SC06_030/ov_SC06_030_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801844F4[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801844F4[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_032/ov_SC06_032_after.c b/src/ov_SC06_032/ov_SC06_032_after.c
index 405721d0e7..34e55a45b5 100644
--- a/src/ov_SC06_032/ov_SC06_032_after.c
+++ b/src/ov_SC06_032/ov_SC06_032_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80194E1C[];
+    extern s32 (*D_80194E1C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus5)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus5)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80194E1C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80194E1C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus5)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus5)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.c b/src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.c
index 1ae63d6e61..25d8fe32d5 100644
--- a/src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.c
+++ b/src/ov_SC06_032/ov_SC06_032_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801937BC[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus4)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80193734; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80193794;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80193734 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8019379C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80193794;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8019379C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801937BC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801937BC + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80193704;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80193704;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801938B8);
     u16 *pB = (*(u16 * *)&D_801938B4);
     u16 *pC = (*(u16 * *)&D_801938C0);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801CF228;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801CF228 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801CF228 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_801938BC;
     extern u16 D_801CF228;
 
-    register s16 *pb0 __asm__("$9");   /* D_801938B8 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");   /* D_801938B4 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$8");   /* D_801938C0 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_801938B8;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = ((u16 *)p2)[0]; pac = D_801938B4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801938C0); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_801938B4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_801938C0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801CF218;
+    a1v = pac[0]; a2v = pac[2];
     D_801CF228 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801CF218)) {
     found:
         pb4 = (*(u16 * *)&D_801938BC);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_801938B4;
     extern u8 D_801938B8;
     extern u8 D_801938C0;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_801938B8);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = p2[0]; pac = (*(s16 * *)&D_801938B4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_801938C0); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_801938B4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_801938C0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801CF218;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-    D_801CF228 = 0;
+    ((H16 *)&D_801CF228)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_801938BC);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_032/ov_SC06_032_jr_8015C32C.c b/src/ov_SC06_032/ov_SC06_032_jr_8015C32C.c
index 89edcfe86f..bc3b3850c2 100644
--- a/src/ov_SC06_032/ov_SC06_032_jr_8015C32C.c
+++ b/src/ov_SC06_032/ov_SC06_032_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_801959C0[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_801959C0[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC06_033/ov_SC06_033_after.c b/src/ov_SC06_033/ov_SC06_033_after.c
index 490a00f0ab..4ac08128de 100644
--- a/src/ov_SC06_033/ov_SC06_033_after.c
+++ b/src/ov_SC06_033/ov_SC06_033_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8019332C[];
+    extern s32 (*D_8019332C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus5)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus5)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8019332C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8019332C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus5)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus5)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.c b/src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.c
index b219903561..6ab6e1cdc3 100644
--- a/src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.c
+++ b/src/ov_SC06_033/ov_SC06_033_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80191CCC[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus4)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80191C44; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80191CA4;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80191C44 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80191CAC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80191CA4;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80191CAC + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80191CCC; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80191CCC + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80191C14;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80191C14;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80191DC8);
     u16 *pB = (*(u16 * *)&D_80191DC4);
     u16 *pC = (*(u16 * *)&D_80191DD0);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801CF2E8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801CF2E8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801CF2E8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80191DCC;
     extern u16 D_801CF2E8;
 
-    register s16 *pb0 __asm__("$9");   /* D_80191DC8 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");   /* D_80191DC4 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$8");   /* D_80191DD0 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80191DC8;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = ((u16 *)p2)[0]; pac = D_80191DC4; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80191DD0); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80191DC4; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80191DD0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801CF2D8;
+    a1v = pac[0]; a2v = pac[2];
     D_801CF2E8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801CF2D8)) {
     found:
         pb4 = (*(u16 * *)&D_80191DCC);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80191DC4;
     extern u8 D_80191DC8;
     extern u8 D_80191DD0;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80191DC8);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80191DC4); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80191DD0); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80191DC4); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80191DD0); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801CF2D8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-    D_801CF2E8 = 0;
+    ((H16 *)&D_801CF2E8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80191DCC);
         p2[0] = pb4[0];
diff --git a/src/ov_SC06_033/ov_SC06_033_jr_8015C32C.c b/src/ov_SC06_033/ov_SC06_033_jr_8015C32C.c
index 74b6314c1a..bf7af46d3c 100644
--- a/src/ov_SC06_033/ov_SC06_033_jr_8015C32C.c
+++ b/src/ov_SC06_033/ov_SC06_033_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80193ED0[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80193ED0[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC07_000/ov_SC07_000_after.c b/src/ov_SC07_000/ov_SC07_000_after.c
index 13c82ec81a..7ae2396939 100644
--- a/src/ov_SC07_000/ov_SC07_000_after.c
+++ b/src/ov_SC07_000/ov_SC07_000_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80184174[];
+    extern s32 (*D_80184174[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus5)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus5)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80184174[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80184174[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus5)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus5)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.c b/src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.c
index e76911069e..674576ee6c 100644
--- a/src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.c
+++ b/src/ov_SC07_000/ov_SC07_000_jr_8012ACE0.c
@@ -1126,156 +1126,136 @@ extern s16 D_80182B14[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus4)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182A8C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80182AEC;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80182A8C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182AF4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80182AEC;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80182AF4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182B14; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80182B14 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80182A5C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80182A5C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2309,15 +2289,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80182C10);
     u16 *pB = (*(u16 * *)&D_80182C0C);
     u16 *pC = (*(u16 * *)&D_80182C18);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2328,15 +2308,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2349,10 +2329,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2780,57 +2760,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801CE830;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801CE830 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801CE830 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2941,26 +2916,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80182C14;
     extern u16 D_801CE830;
 
-    register s16 *pb0 __asm__("$9");   /* D_80182C10 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");   /* D_80182C0C -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$8");   /* D_80182C18 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80182C10;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = ((u16 *)p2)[0]; pac = D_80182C0C; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182C18); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80182C0C; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80182C18); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801CE820;
+    a1v = pac[0]; a2v = pac[2];
     D_801CE830 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801CE820)) {
     found:
         pb4 = (*(u16 * *)&D_80182C14);
         ((u16 *)p2)[0] = pb4[0];
@@ -3006,23 +2980,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80182C0C;
     extern u8 D_80182C10;
     extern u8 D_80182C18;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80182C10);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80182C0C); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80182C18); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80182C0C); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80182C18); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801CE820;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-    D_801CE830 = 0;
+    ((H16 *)&D_801CE830)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80182C14);
         p2[0] = pb4[0];
diff --git a/src/ov_SC07_000/ov_SC07_000_jr_8015C32C.c b/src/ov_SC07_000/ov_SC07_000_jr_8015C32C.c
index eac04dfadc..01094ae041 100644
--- a/src/ov_SC07_000/ov_SC07_000_jr_8015C32C.c
+++ b/src/ov_SC07_000/ov_SC07_000_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80184D18[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80184D18[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC07_000/ov_SC07_000_jr_8017ECB4.c b/src/ov_SC07_000/ov_SC07_000_jr_8017ECB4.c
index fb9333313d..8359f02430 100644
--- a/src/ov_SC07_000/ov_SC07_000_jr_8017ECB4.c
+++ b/src/ov_SC07_000/ov_SC07_000_jr_8017ECB4.c
@@ -2873,10 +2873,9 @@ extern void func_8012B200(u8 *a0);
     }
 
 
-void func_8017EEC0(void) {
+void func_8017EEC0(s32 *a0) {
     extern void func_8012AD44(s32 *a0, s16 a1);
-    s32 a0v;
-    func_8012AD44((s32 *)a0v, 3);
+    func_8012AD44(a0, 3);
 }
 
 
diff --git a/src/ov_SC07_001/ov_SC07_001_after.c b/src/ov_SC07_001/ov_SC07_001_after.c
index 81d4c88a9d..383dc158c9 100644
--- a/src/ov_SC07_001/ov_SC07_001_after.c
+++ b/src/ov_SC07_001/ov_SC07_001_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80183024[];
+    extern s32 (*D_80183024[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus5)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus5)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80183024[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80183024[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus5)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus5)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.c b/src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.c
index 29c886f3a4..3ca087c953 100644
--- a/src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.c
+++ b/src/ov_SC07_001/ov_SC07_001_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_801819C4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus4)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018193C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018199C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018193C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801819A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018199C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801819A4 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801819C4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801819C4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018190C;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018190C;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80181AC0);
     u16 *pB = (*(u16 * *)&D_80181ABC);
     u16 *pC = (*(u16 * *)&D_80181AC8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A98E0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A98E0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A98E0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80181AC4;
     extern u16 D_801A98E0;
 
-    register s16 *pb0 __asm__("$9");   /* D_80181AC0 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");   /* D_80181ABC -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$8");   /* D_80181AC8 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80181AC0;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = ((u16 *)p2)[0]; pac = D_80181ABC; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181AC8); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80181ABC; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80181AC8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A98D0;
+    a1v = pac[0]; a2v = pac[2];
     D_801A98E0 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A98D0)) {
     found:
         pb4 = (*(u16 * *)&D_80181AC4);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80181ABC;
     extern u8 D_80181AC0;
     extern u8 D_80181AC8;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80181AC0);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80181ABC); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80181AC8); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80181ABC); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80181AC8); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A98D0;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-    D_801A98E0 = 0;
+    ((H16 *)&D_801A98E0)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80181AC4);
         p2[0] = pb4[0];
diff --git a/src/ov_SC07_001/ov_SC07_001_jr_8015C32C.c b/src/ov_SC07_001/ov_SC07_001_jr_8015C32C.c
index 6db51f38e9..dcfcbc9643 100644
--- a/src/ov_SC07_001/ov_SC07_001_jr_8015C32C.c
+++ b/src/ov_SC07_001/ov_SC07_001_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80183BC8[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80183BC8[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC07_002/ov_SC07_002_after.c b/src/ov_SC07_002/ov_SC07_002_after.c
index 476c9e1e6c..7a18cfaf4a 100644
--- a/src/ov_SC07_002/ov_SC07_002_after.c
+++ b/src/ov_SC07_002/ov_SC07_002_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801882E0[];
+    extern s32 (*D_801882E0[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus5)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus5)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801882E0[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801882E0[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus5)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus5)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.c b/src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.c
index e2ada33291..5c5cbb8f2b 100644
--- a/src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.c
+++ b/src/ov_SC07_002/ov_SC07_002_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_80186C80[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus4)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186BF8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80186C58;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80186BF8 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186C60; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80186C58;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80186C60 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80186C80; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80186C80 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80186BC8;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80186BC8;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80186D7C);
     u16 *pB = (*(u16 * *)&D_80186D78);
     u16 *pC = (*(u16 * *)&D_80186D84);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8019A430;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8019A430 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8019A430 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_80186D80;
     extern u16 D_8019A430;
 
-    register s16 *pb0 __asm__("$9");   /* D_80186D7C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");   /* D_80186D78 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$8");   /* D_80186D84 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_80186D7C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = ((u16 *)p2)[0]; pac = D_80186D78; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186D84); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_80186D78; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_80186D84); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8019A420;
+    a1v = pac[0]; a2v = pac[2];
     D_8019A430 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8019A420)) {
     found:
         pb4 = (*(u16 * *)&D_80186D80);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_80186D78;
     extern u8 D_80186D7C;
     extern u8 D_80186D84;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_80186D7C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = p2[0]; pac = (*(s16 * *)&D_80186D78); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_80186D84); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_80186D78); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_80186D84); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8019A420;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-    D_8019A430 = 0;
+    ((H16 *)&D_8019A430)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_80186D80);
         p2[0] = pb4[0];
diff --git a/src/ov_SC07_002/ov_SC07_002_jr_8015C32C.c b/src/ov_SC07_002/ov_SC07_002_jr_8015C32C.c
index 7ff2923f8f..fdb7fecf6a 100644
--- a/src/ov_SC07_002/ov_SC07_002_jr_8015C32C.c
+++ b/src/ov_SC07_002/ov_SC07_002_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80188E84[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80188E84[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC07_006/ov_SC07_006.c b/src/ov_SC07_006/ov_SC07_006.c
index 2b687b89b3..9671d12328 100644
--- a/src/ov_SC07_006/ov_SC07_006.c
+++ b/src/ov_SC07_006/ov_SC07_006.c
@@ -2106,156 +2106,136 @@ extern s16 D_8018A8A4[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus9)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A81C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8018A87C;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8018A81C + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A884; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8018A87C;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8018A884 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8018A8A4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8018A8A4 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8018A7EC;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8018A7EC;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
diff --git a/src/ov_SC07_006/ov_SC07_006_jr_80131340.c b/src/ov_SC07_006/ov_SC07_006_jr_80131340.c
index af7a6cb124..c3bfa4cbcb 100644
--- a/src/ov_SC07_006/ov_SC07_006_jr_80131340.c
+++ b/src/ov_SC07_006/ov_SC07_006_jr_80131340.c
@@ -1475,15 +1475,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8018A9A0);
     u16 *pB = (*(u16 * *)&D_8018A99C);
     u16 *pC = (*(u16 * *)&D_8018A9A8);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -1494,15 +1494,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -1515,10 +1515,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -1949,57 +1949,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801F4DD8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801F4DD8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801F4DD8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
diff --git a/src/ov_SC07_006/ov_SC07_006_jr_801457A4.c b/src/ov_SC07_006/ov_SC07_006_jr_801457A4.c
index 2fae539031..14162db6e9 100644
--- a/src/ov_SC07_006/ov_SC07_006_jr_801457A4.c
+++ b/src/ov_SC07_006/ov_SC07_006_jr_801457A4.c
@@ -1833,38 +1833,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8018BF04[];
+    extern s32 (*D_8018BF04[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus2)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus2)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8018BF04[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8018BF04[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus2)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus2)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus2)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC07_007/ov_SC07_007.c b/src/ov_SC07_007/ov_SC07_007.c
index eb7602e57e..7694e3da03 100644
--- a/src/ov_SC07_007/ov_SC07_007.c
+++ b/src/ov_SC07_007/ov_SC07_007.c
@@ -1907,156 +1907,136 @@ extern s16 D_801833C8[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus9)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80183340; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_801833A0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_80183340 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801833A8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_801833A0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_801833A8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801833C8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_801833C8 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_80183310;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_80183310;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
diff --git a/src/ov_SC07_007/ov_SC07_007_jr_80131340.c b/src/ov_SC07_007/ov_SC07_007_jr_80131340.c
index b276ef02c8..c5cd801e4b 100644
--- a/src/ov_SC07_007/ov_SC07_007_jr_80131340.c
+++ b/src/ov_SC07_007/ov_SC07_007_jr_80131340.c
@@ -1472,15 +1472,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_801834C4);
     u16 *pB = (*(u16 * *)&D_801834C0);
     u16 *pC = (*(u16 * *)&D_801834CC);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -1491,15 +1491,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -1512,10 +1512,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -1946,57 +1946,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801C6540;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801C6540 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801C6540 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
diff --git a/src/ov_SC07_007/ov_SC07_007_jr_801457A4.c b/src/ov_SC07_007/ov_SC07_007_jr_801457A4.c
index 14cb8ad211..8e9aff8410 100644
--- a/src/ov_SC07_007/ov_SC07_007_jr_801457A4.c
+++ b/src/ov_SC07_007/ov_SC07_007_jr_801457A4.c
@@ -1773,38 +1773,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80184A28[];
+    extern s32 (*D_80184A28[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus2)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus2)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80184A28[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80184A28[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus2)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus2)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus2)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC07_008/ov_SC07_008_after.c b/src/ov_SC07_008/ov_SC07_008_after.c
index 2db3232b52..3b2b85f261 100644
--- a/src/ov_SC07_008/ov_SC07_008_after.c
+++ b/src/ov_SC07_008/ov_SC07_008_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8017EDF8[];
+    extern s32 (*D_8017EDF8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus5)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus5)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8017EDF8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8017EDF8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus5)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus5)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.c b/src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.c
index 6d27321eaf..2552361d2f 100644
--- a/src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.c
+++ b/src/ov_SC07_008/ov_SC07_008_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017D798[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus4)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017D710; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017D770;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017D710 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017D778; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017D770;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017D778 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017D798; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017D798 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017D6E0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017D6E0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017D894);
     u16 *pB = (*(u16 * *)&D_8017D890);
     u16 *pC = (*(u16 * *)&D_8017D89C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_80195318;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_80195318 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_80195318 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017D898;
     extern u16 D_80195318;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017D894 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");   /* D_8017D890 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$8");   /* D_8017D89C -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017D894;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = ((u16 *)p2)[0]; pac = D_8017D890; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017D89C); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017D890; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017D89C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_80195308;
+    a1v = pac[0]; a2v = pac[2];
     D_80195318 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_80195308)) {
     found:
         pb4 = (*(u16 * *)&D_8017D898);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017D890;
     extern u8 D_8017D894;
     extern u8 D_8017D89C;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017D894);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017D890); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017D89C); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017D890); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017D89C); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_80195308;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-    D_80195318 = 0;
+    ((H16 *)&D_80195318)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017D898);
         p2[0] = pb4[0];
diff --git a/src/ov_SC07_008/ov_SC07_008_jr_8015C32C.c b/src/ov_SC07_008/ov_SC07_008_jr_8015C32C.c
index e5f0bfc98e..47792a8e00 100644
--- a/src/ov_SC07_008/ov_SC07_008_jr_8015C32C.c
+++ b/src/ov_SC07_008/ov_SC07_008_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_8017F99C[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_8017F99C[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC07_009/ov_SC07_009_after.c b/src/ov_SC07_009/ov_SC07_009_after.c
index 25b565ed0e..8ad9b21447 100644
--- a/src/ov_SC07_009/ov_SC07_009_after.c
+++ b/src/ov_SC07_009/ov_SC07_009_after.c
@@ -639,38 +639,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_8017F89C[];
+    extern s32 (*D_8017F89C[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus5)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus5)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_8017F89C[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_8017F89C[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus5)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus5)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus5)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.c b/src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.c
index de240e1ee9..6662a2bcf2 100644
--- a/src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.c
+++ b/src/ov_SC07_009/ov_SC07_009_jr_8012ACE0.c
@@ -1124,156 +1124,136 @@ extern s16 D_8017E23C[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus4)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E1B4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017E214;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017E1B4 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E21C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017E214;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017E21C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017E23C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus4)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017E23C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017E184;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017E184;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
@@ -2307,15 +2287,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017E338);
     u16 *pB = (*(u16 * *)&D_8017E334);
     u16 *pC = (*(u16 * *)&D_8017E340);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -2326,15 +2306,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -2347,10 +2327,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -2778,57 +2758,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A29A8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A29A8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A29A8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
@@ -2939,26 +2914,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017E33C;
     extern u16 D_801A29A8;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017E338 -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");   /* D_8017E334 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$8");   /* D_8017E340 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017E338;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = ((u16 *)p2)[0]; pac = D_8017E334; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E340); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017E334; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017E340); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_801A2998;
+    a1v = pac[0]; a2v = pac[2];
     D_801A29A8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_801A2998)) {
     found:
         pb4 = (*(u16 * *)&D_8017E33C);
         ((u16 *)p2)[0] = pb4[0];
@@ -3004,23 +2978,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017E334;
     extern u8 D_8017E338;
     extern u8 D_8017E340;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B tus4)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B tus4)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017E338);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017E334); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017E340); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017E334); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017E340); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_801A2998;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus4)
-    D_801A29A8 = 0;
+    ((H16 *)&D_801A29A8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017E33C);
         p2[0] = pb4[0];
diff --git a/src/ov_SC07_009/ov_SC07_009_jr_8015C32C.c b/src/ov_SC07_009/ov_SC07_009_jr_8015C32C.c
index 1735db76ff..a9639dc33a 100644
--- a/src/ov_SC07_009/ov_SC07_009_jr_8015C32C.c
+++ b/src/ov_SC07_009/ov_SC07_009_jr_8015C32C.c
@@ -1949,19 +1949,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80180440[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B tus4)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80180440[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/ov_SC07_010/ov_SC07_010.c b/src/ov_SC07_010/ov_SC07_010.c
index dc9c08da66..12d227bc3f 100644
--- a/src/ov_SC07_010/ov_SC07_010.c
+++ b/src/ov_SC07_010/ov_SC07_010.c
@@ -1907,156 +1907,136 @@ extern s16 D_80182458[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus9)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_801823D0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_80182430;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_801823D0 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182438; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_80182430;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_80182438 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_80182458; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_80182458 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_801823A0;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_801823A0;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
diff --git a/src/ov_SC07_010/ov_SC07_010_jr_80131340.c b/src/ov_SC07_010/ov_SC07_010_jr_80131340.c
index 5f2851acc5..a0292132a2 100644
--- a/src/ov_SC07_010/ov_SC07_010_jr_80131340.c
+++ b/src/ov_SC07_010/ov_SC07_010_jr_80131340.c
@@ -1477,15 +1477,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_80182554);
     u16 *pB = (*(u16 * *)&D_80182550);
     u16 *pC = (*(u16 * *)&D_8018255C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -1496,15 +1496,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -1517,10 +1517,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -1951,57 +1951,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_801A6A38;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_801A6A38 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_801A6A38 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
diff --git a/src/ov_SC07_010/ov_SC07_010_jr_801457A4.c b/src/ov_SC07_010/ov_SC07_010_jr_801457A4.c
index 415629a231..bd9d4c5f9a 100644
--- a/src/ov_SC07_010/ov_SC07_010_jr_801457A4.c
+++ b/src/ov_SC07_010/ov_SC07_010_jr_801457A4.c
@@ -1174,38 +1174,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80183AB8[];
+    extern s32 (*D_80183AB8[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus2)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus2)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80183AB8[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80183AB8[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus2)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus2)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus2)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/ov_SC07_011/ov_SC07_011.c b/src/ov_SC07_011/ov_SC07_011.c
index 1c20e2c2d0..ba3f9544ab 100644
--- a/src/ov_SC07_011/ov_SC07_011.c
+++ b/src/ov_SC07_011/ov_SC07_011.c
@@ -1907,156 +1907,136 @@ extern s16 D_8017EB18[];
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung B tus9)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EA90; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017EAF0;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017EA90 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EAF8; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017EAF0;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017EAF8 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EB18; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus9)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017EB18 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017EA60;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017EA60;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
 
diff --git a/src/ov_SC07_011/ov_SC07_011_jr_80131340.c b/src/ov_SC07_011/ov_SC07_011_jr_80131340.c
index 68e9726b32..584a6ca88b 100644
--- a/src/ov_SC07_011/ov_SC07_011_jr_80131340.c
+++ b/src/ov_SC07_011/ov_SC07_011_jr_80131340.c
@@ -1472,15 +1472,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017EC14);
     u16 *pB = (*(u16 * *)&D_8017EC10);
     u16 *pC = (*(u16 * *)&D_8017EC1C);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -1491,15 +1491,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -1512,10 +1512,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
@@ -1946,57 +1946,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8018F0D0;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B tus4)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung B tus4)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus4)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B tus4)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8018F0D0 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B tus4)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8018F0D0 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
diff --git a/src/ov_SC07_011/ov_SC07_011_jr_801457A4.c b/src/ov_SC07_011/ov_SC07_011_jr_801457A4.c
index 74c9a41cd2..0027d42f6b 100644
--- a/src/ov_SC07_011/ov_SC07_011_jr_801457A4.c
+++ b/src/ov_SC07_011/ov_SC07_011_jr_801457A4.c
@@ -1774,38 +1774,24 @@ extern s32 ratan2(s32 a0, s32 a1);
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80180178[];
+    extern s32 (*D_80180178[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung B tus2)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung B tus2)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80180178[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80180178[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung B tus2)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus2)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung B tus2)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B tus2)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
 
diff --git a/src/shared/ov/func_80130D48__bbfb4341.h b/src/shared/ov/func_80130D48__bbfb4341.h
index 9e7ea418d8..72d5a47afd 100644
--- a/src/shared/ov/func_80130D48__bbfb4341.h
+++ b/src/shared/ov/func_80130D48__bbfb4341.h
@@ -3,155 +3,135 @@
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A headers2)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EED4; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A headers2)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017EF34;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017EED4 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF3C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A headers2)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017EF34;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017EF3C + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017EF5C; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A headers2)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017EF5C + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017EEA4;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017EEA4;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
diff --git a/src/shared/ov/func_80130D48__f3dfe4ca.h b/src/shared/ov/func_80130D48__f3dfe4ca.h
index 0d1067f807..d401366b6c 100644
--- a/src/shared/ov/func_80130D48__f3dfe4ca.h
+++ b/src/shared/ov/func_80130D48__f3dfe4ca.h
@@ -3,155 +3,135 @@
 void func_80130D48(s32 arg0)
 {
     s16 *tbl;
-    s32 pa = arg0;
-    register u8 *p  __asm__("$19") = D_80078E78;  // !FAKE: pin $19 — NEEDED DIFFERS (P36 rung A headers1)
-    s32 s1v;
-    s32 call_a0;
-    s32 call_a1;
-    s32 cnt;
+    u8 *p = D_80078E78;
+    s32 val;
+    s32 i;
+    s32 j;
     s32 r;
-    void *ret;
+    s32 ret;
 
-    s1v = func_80131CF4(*(s32 *)((s8 *)pa + 0xBC), 0x15);
-    if (s1v == 0) {
+    val = func_80131CF4(*(s32 *)((s8 *)arg0 + 0xBC), 0x15);
+    if (val == 0) {
         return;
     }
 
-    if (*(u8 *)((s8 *)pa + 0x5E) == 0xB) {
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    }
+    if (*(u8 *)((s8 *)arg0 + 0x5E) == 0xB) {
+        ret = func_8012C658(0x33, 0, arg0);
+    } else {
+        switch (val & 0xFFFF0000) {
+        case 0x10000: {
+            u32 x = D_80078EB4;
+            u32 y = D_80078EB2;
+            u32 b;
+            u32 a;
 
-    switch (s1v & 0xFFFF0000) {
-    case 0x10000: {
-        u32 x = D_80078EB4;
-        u32 y = D_80078EB2;
-        u32 b;
-        u32 a;
-
-        s1v = 0;
-        if (x == y) {
-            s1v = 0xC;
-        } else if ((y >> 1) >= x) {
-            s1v = 3;
-        }
-
-        b = *(u16 *)(p + 0x40);
-        a = *(u16 *)(p + 0x3E);
-        if (b == a) {
-            s1v += 0x18;
-        } else if ((a >> 1) >= b) {
-            s1v += 6;
-        }
-        { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F688; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A headers1)
-
-        r = rand() % 100;
-        cnt = 0;
-    loop27:
-        if (r >= *tbl) {
-            cnt += 1;
-            tbl += 1;
-            if (cnt < 3) {
-                goto loop27;
+            val = 0;
+            if (x == y) {
+                val = 0xC;
+            } else if ((y >> 1) >= x) {
+                val = 3;
             }
-        }
 
-        s1v = 0;
-        switch (cnt) {
-        case 0:
-            tbl = D_8017F6E8;
-            s1v = 0x31;
-            break;
-        case 1: {
-            s32 mx = *(u16 *)(p + 0x3A);
-            s32 cur = *(u16 *)(p + 0x3C);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
-                    }
+            b = *(u16 *)(p + 0x40);
+            a = *(u16 *)(p + 0x3E);
+            if (b == a) {
+                val += 0x18;
+            } else if ((a >> 1) >= b) {
+                val += 6;
+            }
+            tbl = D_8017F688 + val;
+
+            r = rand() % 100;
+            for (i = 0; i < 3; i++, tbl++) {
+                if (r < *tbl) {
+                    break;
                 }
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F6F0; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A headers1)
-            s1v = 0x32;
-            break;
-        }
-        case 2: {
-            s32 mx = *(u16 *)(p + 0x3E);
-            s32 cur = *(u16 *)(p + 0x40);
-            if (((mx * 7) / 10) >= cur) {
-                s1v = 4;
-                if ((mx / 2) >= cur) {
-                    s1v = 8;
-                    if ((mx / 5) >= cur) {
-                        s1v = 0xC;
+
+            val = 0;
+            switch (i) {
+            case 0:
+                tbl = D_8017F6E8;
+                val = 0x31;
+                break;
+            case 1: {
+                s32 mx = *(u16 *)(p + 0x3A);
+                s32 cur = *(u16 *)(p + 0x3C);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
                     }
                 }
+                tbl = D_8017F6F0 + val;
+                val = 0x32;
+                break;
             }
-            { register s32 v1 __asm__("$3"); s8 *bp; v1 = s1v * 2; bp = (s8 *)D_8017F710; tbl = (s16 *)(bp + v1); }  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A headers1)
-            s1v = 0x33;
+            case 2: {
+                s32 mx = *(u16 *)(p + 0x3E);
+                s32 cur = *(u16 *)(p + 0x40);
+                if (((mx * 7) / 10) >= cur) {
+                    val = 4;
+                    if ((mx / 2) >= cur) {
+                        val = 8;
+                        if ((mx / 5) >= cur) {
+                            val = 0xC;
+                        }
+                    }
+                }
+                tbl = D_8017F710 + val;
+                val = 0x33;
+                break;
+            }
+            }
+
+            r = rand() % 100;
+            for (j = 0; j < 4; j++, tbl++) {
+                if (r < *tbl) {
+                    break;
+                }
+            }
+            ret = func_8012C658(val, j, arg0);
             break;
         }
-        }
-
-        r = rand() % 100;
-        call_a1 = 0;
-    loop50:
-        if (r >= *tbl) {
-            call_a1 += 1;
-            tbl += 1;
-            if (call_a1 < 4) {
-                goto loop50;
-            }
-        }
-        call_a0 = s1v;
-        goto do_call;
-    }
-    case 0x20000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x30000:
-        call_a0 = 0x31;
-        call_a1 = 0;
-        goto do_call;
-    case 0x40000:
-        call_a0 = 0x32;
-        call_a1 = 0;
-        goto do_call;
-    case 0x50000:
-        call_a0 = 0x33;
-        call_a1 = 0;
-        goto do_call;
-    case 0x60000: {
-        s32 rr = rand() & 0xFF;
-        tbl = D_8017F658;
-        if (rr >= *tbl) {
-            do {
+        case 0x20000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x30000:
+            ret = func_8012C658(0x31, 0, arg0);
+            break;
+        case 0x40000:
+            ret = func_8012C658(0x32, 0, arg0);
+            break;
+        case 0x50000:
+            ret = func_8012C658(0x33, 0, arg0);
+            break;
+        case 0x60000: {
+            s32 rr = rand() & 0xFF;
+            s32 id;
+            tbl = D_8017F658;
+            while (rr >= *tbl) {
                 tbl += 3;
-            } while (rr >= *tbl);
+            }
+            id = tbl[1];
+            if (*(u16 *)(p + 0x40) < 4U) {
+                id = 0x33;
+            }
+            ret = func_8012C658(id, tbl[2], arg0);
+            break;
         }
-        call_a0 = tbl[1];
-        if (*(u16 *)(p + 0x40) < 4U) {
-            call_a0 = 0x33;
+        case 0x70000:
+            ret = func_8012C658(0x27B, 0, arg0);
+            break;
+        default:
+            return;
         }
-        call_a1 = tbl[2];
-        goto do_call;
-    }
-    case 0x70000:
-        call_a0 = 0x27B;
-        call_a1 = 0;
-        goto do_call;
-    default:
-        return;
     }
 
-do_call:
-    ret = func_8012C658(call_a0, call_a1, pa);
     if (ret != 0) {
-        *(u16 *)((s8 *)ret + 0xA) -= 0x20;
+        *(u16 *)(ret + 0xA) -= 0x20;
     }
 }
diff --git a/src/shared/ov/func_80133AB0__49df14d8.h b/src/shared/ov/func_80133AB0__49df14d8.h
index 328dfc5df5..a51ab9ba01 100644
--- a/src/shared/ov/func_80133AB0__49df14d8.h
+++ b/src/shared/ov/func_80133AB0__49df14d8.h
@@ -13,15 +13,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     u16 *pA = (*(u16 * *)&D_8017F80C);
     u16 *pB = (*(u16 * *)&D_8017F808);
     u16 *pC = (*(u16 * *)&D_8017F814);
-    register int zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung B headers1)
-    u32 X, Y, cell, Xc, Yc;
+    u32 X, Y, cell;
+    u16 Xc, Yc;
     u16 k, off;
-    int cnt;
+    u16 cnt;
     u16 *cp, *lst;
     u8 *s0;
     u16 raw;
     u32 hib;
-    register int harg __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B headers1)
+    u16 harg;
     s32 ret;
     void *p0C, *p10;
     u8 *p14, *p18, *p1C;
@@ -32,15 +32,15 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     pC[2] = pA[2] - pB[2];
 
     X = ((((u16)x + 0x8000) >> 7) & 0x1ff) - map->ox;
-    __asm__("addu %0,%1,$zero" : "=r"(Xc) : "r"(X));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B headers1)
+    Xc = X;
     if (!((X & 0xffff) < map->w))
         return 0;
     Y = ((((u16)y + 0x8000) >> 7) & 0x1ff) - map->oy;
-    __asm__("addu %0,%1,$zero" : "=r"(Yc) : "r"(Y));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung B headers1)
+    Yc = Y;
     if (!((Y & 0xffff) < map->h))
         return 0;
 
-    cell = (Yc & 0xffff) * map->w + (Xc & 0xffff);
+    cell = Yc * map->w + Xc;
     cells = map->cells;
     p14 = map->p14;
     p0C = map->p0C;
@@ -53,10 +53,10 @@ s32 func_80133AB0(s16 flag, s16 x, s16 y, s32 arg3)
     cnt = cp[1];
     lst = (u16 *)(p14 + off);
 
-    while (((cnt-- + zr) & 0xffff) != 0) {
+    while (cnt-- != 0) {
         raw = *lst;
         hib = raw & 0x8000;
-        harg = hib + zr;
+        harg = hib;
         if (hib == 0) {
             s0 = p18 + raw * 18;
         } else {
diff --git a/src/shared/ov/func_80134A74__38c10a1a.h b/src/shared/ov/func_80134A74__38c10a1a.h
index 59b38f96e1..5c0e39b2f2 100644
--- a/src/shared/ov/func_80134A74__38c10a1a.h
+++ b/src/shared/ov/func_80134A74__38c10a1a.h
@@ -5,57 +5,52 @@ int func_80134A74(int param_1, s16 param_2, s16 param_3, int param_4)
     extern u16 D_8018E6F8;
     extern s32 func_80134C20(s32, s32, s32, s32);
 
-    u16 *param_4p = (u16 *)param_4;
-    register u32 zr __asm__("$0");  // !FAKE: pin $0 — NEEDED DIFFERS (P36 rung A headers1)
-    u32 uVar6, uVar2, uVar2c;
-    u32 uVar6c;
-    u16 *puVar4, *ptmp;
-    register u32 n __asm__("$18");  // !FAKE: pin $18 — NEEDED DIFFERS (P36 rung A headers1)
-    register u32 p0 __asm__("$4");  // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung A headers1)
-    int v14;
-    u16 *puVar7, uVar1;
-    u32 hi, hic;
-    int iVar5, iVar9, iVar8, uVar3, uVar10;
+    Map_80133AB0 *map = (Map_80133AB0 *)param_4;
+    u32 X, Y;
+    u16 Xc, Yc;
+    u16 k, off, cnt;
+    u16 *cp, *lst;
+    u16 raw;
+    u32 hib;
+    u16 harg;
+    u8 *s0;
+    void *p0C, *p10;
+    u8 *p14, *p18, *p1C;
 
-    uVar6 = ((int)((param_2 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[0];
-    uVar6c = uVar6 + zr;
-    if ((uVar6 & 0xffff) < (u32)param_4p[2]) {
-        uVar2 = ((int)((param_3 & 0xffff) + 0x8000) >> 7 & 0x1ff) - (u32)param_4p[1];
-        __asm__("addu %0,%1,$zero" : "=r"(uVar2c) : "r"(uVar2));  // !FAKE: instruction addu — NEEDED DIFFERS (P36 rung A headers1)
-        if ((uVar2 & 0xffff) < (u32)param_4p[3]) goto work;
+    X = ((((u16)param_2 + 0x8000) >> 7) & 0x1ff) - map->ox;
+    Xc = X;
+    if ((u16)X >= map->w)
         return 0;
-    found:
-        D_8018E6F8 = *puVar7;
-        return 1;
-    work:
-        uVar10 = *(int *)(param_4p + 6);
-        uVar3 = *(int *)(param_4p + 8);
-        iVar9 = *(int *)(param_4p + 0xc);
-        iVar8 = *(int *)(param_4p + 0xe);
-        ptmp = (u16 *)((((uVar2c & 0xffff) * (u32)param_4p[2] + (uVar6c & 0xffff)) * 2 & 0xffff) * 2 + *(int *)(param_4p + 4));
-        v14 = *(int *)(param_4p + 10);
-        __asm__ __volatile__("" :: "r"(uVar6c));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A headers1)
-        p0 = (u32)*ptmp;
-        n = (u32)ptmp[1];
-        puVar4 = (u16 *)(v14 + p0 + n * 2) - 1;
-        goto test;
-    body:
-        uVar1 = *puVar4;
-        hi = uVar1 & 0x8000;
-        hic = hi + zr;
-        if (hi == 0)
-            puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
-        else
-            puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
-        puVar4 = puVar4 - 1;
-        iVar5 = func_80134C20((short)(hic | param_1), (s32)puVar7, uVar3, uVar10);
-        if (iVar5 != 0) goto found;
-    test:
-        {
-            u32 m;
-            m = n;
-            n--;
-            if ((m & 0xffff) != 0) goto body;
+    Y = ((((u16)param_3 + 0x8000) >> 7) & 0x1ff) - map->oy;
+    Yc = Y;
+    if ((u16)Y >= map->h)
+        return 0;
+
+    p0C = map->p0C;
+    p10 = map->p10;
+    p18 = map->p18;
+    p1C = map->p1C;
+    k = (Yc * map->w + Xc) * 2;
+    cp = (u16 *)(k * 2 + (u32)map->cells);
+    p14 = map->p14;
+    off = cp[0];
+    cnt = cp[1];
+    lst = (u16 *)(p14 + off) + cnt - 1;
+
+    while (cnt-- != 0) {
+        raw = *lst;
+        hib = raw & 0x8000;
+        harg = hib;
+        if (hib == 0) {
+            s0 = p18 + raw * 18;
+            lst--;
+        } else {
+            s0 = p1C + (raw & 0x7fff) * 22;
+            lst--;
+        }
+        if (func_80134C20((s16)(harg | param_1), (s32)s0, (s32)p10, (s32)p0C) != 0) {
+            D_8018E6F8 = *(u16 *)s0;
+            return 1;
         }
     }
     return 0;
diff --git a/src/shared/ov/func_80135004__0f8f8d0b.h b/src/shared/ov/func_80135004__0f8f8d0b.h
index 97cb907a5f..efafc7ad57 100644
--- a/src/shared/ov/func_80135004__0f8f8d0b.h
+++ b/src/shared/ov/func_80135004__0f8f8d0b.h
@@ -9,26 +9,25 @@ s32 func_80135004(s32 arg0, s32 p1, s32 p2)
     extern s16 *D_8017F810;
     extern u16 D_8018E6F8;
 
-    register s16 *pb0 __asm__("$9");   /* D_8017F80C -> $t1 */  // !FAKE: pin $9 — NEEDED DIFFERS (P36 rung A headers1)
-    register s16 *pac __asm__("$6");   /* D_8017F808 -> $a2 */  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung A headers1)
-    register s16 *pb8 __asm__("$8");   /* D_8017F814 -> $t0 */  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung A headers1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int id;
-    int a1v, a2v, d94;
+    int a1v, a2v;
 
     pb0 = D_8017F80C;
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A headers1)
 
-    a = ((u16 *)p2)[0]; pac = D_8017F808; pb0[0] = a; b = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F814); pac[0] = b; pb8[0] = a - b;
-    a = ((u16 *)p2)[1]; pb0[1] = a; b = ((u16 *)p1)[1]; pac[1] = b; pb8[1] = a - b;
-    a = ((u16 *)p2)[2]; pb0[2] = a; b = ((u16 *)p1)[2]; pac[2] = b; pb8[2] = a - b;
+    ax = ((u16 *)p2)[0]; pac = D_8017F808; pb0[0] = ax; bx = ((u16 *)p1)[0]; pb8 = (*(s16 * *)&D_8017F814); pac[0] = bx; pb8[0] = ax - bx;
+    ay = ((u16 *)p2)[1]; pb0[1] = ay; by = ((u16 *)p1)[1]; pac[1] = by; pb8[1] = ay - by;
+    az = ((u16 *)p2)[2]; pb0[2] = az; bz = ((u16 *)p1)[2]; pac[2] = bz; pb8[2] = az - bz;
 
     id = ((int)arg0) & 0xFFFF;
-    a1v = pac[0]; a2v = pac[2]; d94 = D_8018E6E8;
+    a1v = pac[0]; a2v = pac[2];
     D_8018E6F8 = 0;
 
-    if (func_80134A74(id, a1v, a2v, d94)) {
+    if (func_80134A74(id, a1v, a2v, D_8018E6E8)) {
     found:
         pb4 = (*(u16 * *)&D_8017F810);
         ((u16 *)p2)[0] = pb4[0];
diff --git a/src/shared/ov/func_80135168__bad0a585.h b/src/shared/ov/func_80135168__bad0a585.h
index 360136b522..13107b398e 100644
--- a/src/shared/ov/func_80135168__bad0a585.h
+++ b/src/shared/ov/func_80135168__bad0a585.h
@@ -8,23 +8,21 @@ int func_80135168(u16 arg0, u16 *p1, u16 *p2)
     extern u8 D_8017F808;
     extern u8 D_8017F80C;
     extern u8 D_8017F814;
-    register s16 *pb0 __asm__("$8");  // !FAKE: pin $8 — NEEDED DIFFERS (P36 rung B headers1)
-    register s16 *pac __asm__("$6");  // !FAKE: pin $6 — NEEDED DIFFERS (P36 rung B headers1)
-    register s16 *pb8 __asm__("$7");  // !FAKE: pin $7 — NEEDED DIFFERS (P36 rung B headers1)
+    s16 *pb0;
+    s16 *pac;
+    s16 *pb8;
     u16 *pb4;
-    u16 a, b;
+    u16 ax, bx, ay, by, az, bz;
     int a1v, a2v, d94;
 
     pb0 = (*(s16 * *)&D_8017F80C);
-    __asm__ __volatile__("" : : "r"(pb0));  // !FAKE: keepalive — NEEDED DIFFERS (P36 rung B headers1)
 
-    a = p2[0]; pac = (*(s16 * *)&D_8017F808); pb0[0] = a; b = p1[0]; pb8 = (*(s16 * *)&D_8017F814); pac[0] = b; pb8[0] = a - b;
-    a = p2[1]; pb0[1] = a; b = p1[1]; pac[1] = b; pb8[1] = a - b;
-    a = p2[2]; pb0[2] = a; b = p1[2]; pac[2] = b; pb8[2] = a - b;
+    ax = p2[0]; pac = (*(s16 * *)&D_8017F808); pb0[0] = ax; bx = p1[0]; pb8 = (*(s16 * *)&D_8017F814); pac[0] = bx; pb8[0] = ax - bx;
+    ay = p2[1]; pb0[1] = ay; by = p1[1]; pac[1] = by; pb8[1] = ay - by;
+    az = p2[2]; pb0[2] = az; bz = p1[2]; pac[2] = bz; pb8[2] = az - bz;
 
     a1v = pac[0]; a2v = pac[2]; d94 = D_8018E6E8;
-    __asm__ __volatile__("" ::: "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung B headers1)
-    D_8018E6F8 = 0;
+    ((H16 *)&D_8018E6F8)->h = 0;
     if (func_80134A74(arg0, a1v, a2v, d94)) {
         pb4 = (*(u16 * *)&D_8017F810);
         p2[0] = pb4[0];
diff --git a/src/shared/ov/func_80148AFC__4d5b7f00.h b/src/shared/ov/func_80148AFC__4d5b7f00.h
index 26336eacc6..9936f82c25 100644
--- a/src/shared/ov/func_80148AFC__4d5b7f00.h
+++ b/src/shared/ov/func_80148AFC__4d5b7f00.h
@@ -3,37 +3,23 @@
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_80180D70[];
+    extern s32 (*D_80180D70[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung A headers2)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung A headers2)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_80180D70[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_80180D70[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A headers2)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung A headers2)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung A headers2)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung A headers2)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
diff --git a/src/shared/ov/func_80148AFC__a6049646.h b/src/shared/ov/func_80148AFC__a6049646.h
index 65db371121..048e8420ae 100644
--- a/src/shared/ov/func_80148AFC__a6049646.h
+++ b/src/shared/ov/func_80148AFC__a6049646.h
@@ -3,37 +3,23 @@
 int func_80148AFC(void *a0) {
 
     extern s32 D_801151D4;
-    extern ActorFn D_801805BC[];
+    extern s32 (*D_801805BC[])(void *, s32);
     s32 p = (s32)a0;
     s32 iVar5 = *(s32 *)(p + 0x20);
-    register s32 tmp __asm__("$5") = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),  // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung A headers2)
-                        *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
-    s32 sVar3;
-    u8 bVar1;
-    __asm__("" : "=r"(tmp) : "0"(tmp));  // !FAKE: launder — NEEDED DIFFERS (P36 rung A headers2)
-    sVar3 = tmp;
-    bVar1 = *(u8 *)(p + 0xA9);
+    s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50),
+                      *(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
+    s32 ang = tmp;
 
-    switch (bVar1) {
+    switch (*(u8 *)(p + 0xA9)) {
     case 0x41:
-        return D_801805BC[*(u16 *)(p + 0xAA) >> 12](a0) & 0xFF;
+        return D_801805BC[*(u16 *)(p + 0xAA) >> 12](a0, tmp) & 0xFF;
     case 0x53:
     case 0x73:
-        {
-            register u32 bb __asm__("$3");  // !FAKE: pin $3 — NEEDED DIFFERS (P36 rung A headers2)
-            register s32 c80 __asm__("$2") = 0x80;  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung A headers2)
-            s32 lo;
-            register s32 hi __asm__("$2");  // !FAKE: pin $2 — NEEDED DIFFERS (P36 rung A headers2)
-            bb = *(u16 *)(p + 0xAE);
-            lo = bb & 0xFF;
-            if (lo != c80 || (hi = bb >> 8) != 0x80) {
-                s32 sVar4;
-                __asm__ __volatile__("" : : : "memory");  // !FAKE: barrier memory — NEEDED DIFFERS (P36 rung A headers2)
-                sVar4 = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
-                *(u16 *)(iVar5 + 0x12) = (sVar3 + sVar4) & 0xFFF;
-                return 1;
-            }
+        if ((*(u16 *)(p + 0xAE) & 0xFF) == 0x80 && (*(u16 *)(p + 0xAE) >> 8) == 0x80) {
             return 0;
         }
+        tmp = ratan2((*(u16 *)(p + 0xAE) & 0xFF) - 0x80, 0x80 - (*(u16 *)(p + 0xAE) >> 8));
+        *(u16 *)(iVar5 + 0x12) = (ang + tmp) & 0xFFF;
+        return 1;
     }
 }
diff --git a/src/shared/ov/func_8015D738__6e729a10.h b/src/shared/ov/func_8015D738__6e729a10.h
index 98998a3a1f..d31607298d 100644
--- a/src/shared/ov/func_8015D738__6e729a10.h
+++ b/src/shared/ov/func_8015D738__6e729a10.h
@@ -9,19 +9,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80181914[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B headers2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80181914[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/src/shared/ov/func_8015D738__d338deef.h b/src/shared/ov/func_8015D738__d338deef.h
index 3b93a67aa7..79076a1cfc 100644
--- a/src/shared/ov/func_8015D738__d338deef.h
+++ b/src/shared/ov/func_8015D738__d338deef.h
@@ -9,19 +9,17 @@ void func_8015D738(void *arg0) {
     ((void (*)(void))func_80148AFC)();
     if (func_80161B18(arg0) != 0) return;
     if (func_80161B84(arg0) != 0) return;
+    do {
+        s1 = *(s32 *)((char *)arg0 + 0x178);
+    } while (0);
+    if (s1 != 0 && *(u16 *)s1 == 0x360) goto block_808;
     s1 = *(s32 *)((char *)arg0 + 0x178);
-    if (s1 != 0) {
-        if (*(u16 *)s1 == 0x360) goto block_808;
+    if (s1 == 0 || *(u16 *)s1 == 0) {
+        D_80181160[*(u16 *)arg0](arg0);
+        ((void (*)(void *, s32))func_80147078)(arg0, 0);
+        func_80159B70(arg0);
+        return;
     }
-    __asm__ __volatile__("");  // !FAKE: barrier — NEEDED DIFFERS (P36 rung B headers2)
-    if (s1 != 0) {
-        if (*(u16 *)s1 != 0) goto block_7F4;
-    }
-    D_80181160[*(u16 *)arg0](arg0);
-    ((void (*)(void *, s32))func_80147078)(arg0, 0);
-    func_80159B70(arg0);
-    return;
-block_7F4:
     if (((s32 (*)(void *))func_80148800)(arg0) & 0x80) {
     block_808:
         ((void (*)(void *, s32))func_80154A74)(arg0, 0x11);
diff --git a/tools/delever.py b/tools/delever.py
index 7733fca694..0e367bed63 100644
--- a/tools/delever.py
+++ b/tools/delever.py
@@ -2775,7 +2775,119 @@ def merge_walked_pointers(text, tu, fn, d_):
     return out
 
 
-ALL_FAMILIES = ("R2", "R3", "R4", "R5", "R6", "R7", "R8", "R9", "R10", "R12", "R13", "R14", "R15", "R16", "R17", "R18", "R19", "R20", "R21", "R22")
+_CTRL = re.compile(r"\b(?:if|else|while|for|do|switch|case|default|goto|return|break|continue)\b")
+_LOOPISH = re.compile(r"\b(?:while|for|do|goto)\b|^\s*[A-Za-z_]\w*\s*:(?!:)", re.M)
+
+
+def split_reused_locals(text, tu, fn, d_):
+    """[(description, candidate text)] — R23: a local that is FULLY REDEFINED several times in straight-line code split
+    into one name per value.
+
+    T7 agents c1 (func_80135168, 125 bodies) and c8 (func_80135004, 126 bodies), P36 S103, both closed a register
+    permutation this way: `u16 a, b;` reused by three statement groups became `u16 ax, bx, ay, by, az, bz;`. A pseudo that
+    dies more than once is not a local-alloc candidate (`local-alloc.c:472` takes only a register that dies exactly once
+    in its block), so the reused temps went to GLOBAL allocation — which runs after local-alloc has already handed the
+    pointers their registers. One name per value makes each a single-death local with a high `qty_compare_1` rank
+    (`local-alloc.c:1598-1625`), so they take `$v0/$v1` first and the pointers fall into the target's order. Both closes
+    were JOINT (c1: this move alone 12, a member store alone 20, both 0; c8: this alone 26, a call argument inlined alone
+    16, both 0), so the family also offers every split at once, and the engine composes it with the other families.
+
+    Refused unless `v` is declared without an initialiser in the body's declaration run, its first mention is a full
+    redefinition `v = E;` whose `E` does not read `v`, it has no other write (`+=`, `++`, …) and no `&v`, the definitions
+    lie in straight-line code (no brace or control keyword between the first and the last), and no loop, `goto` or label
+    lies between the first definition and the last use — a renamed segment can then never be reached with the old value."""
+    lines = text.split("\n")
+    lo, hi = d_["line"], d_["end"] - 1
+    if hi <= lo:
+        return []
+    head = "\n".join(lines[:lo]) + "\n"
+    body = "\n".join(lines[lo:hi])
+    tail = "\n" + "\n".join(lines[hi:])
+    mb = sc.mask_text(body)
+    # declarations are read from the WHOLE-BODY mask: `decl_run_end` masks one line at a time, so a multi-line comment
+    # inside the declaration run ends it early (func_80135168's `[T51]` note returned a run of 0 lines — found by the
+    # known-true check against agent c1's own start text, S103)
+    DL = re.compile(r"^(\s*(?:unsigned\s+|signed\s+|const\s+)*[A-Za-z_]\w*\s+)([A-Za-z_]\w*(?:\s*,\s*[A-Za-z_]\w*)*)\s*;\s*$")
+    decls = {}
+    for j, ml in enumerate(mb.split("\n")):
+        m = DL.match(ml)
+        if m and not m.group(1).strip() in ("return", "goto", "extern", "static", "typedef", "else", "do"):
+            for n in re.split(r"\s*,\s*", m.group(2).strip()):
+                decls[n] = lo + j
+    idents = set(re.findall(r"[A-Za-z_]\w*", text))
+    decl_off = {}                                           # line index -> char offset of that line inside `body`
+    off = 0
+    for i in range(lo, hi):
+        decl_off[i] = off
+        off += len(lines[i]) + 1
+
+    def plan(v):
+        dl_i = decls[v]
+        dl_lo, dl_hi = decl_off[dl_i], decl_off[dl_i] + len(lines[dl_i])
+        occ = [m.start() for m in re.finditer(r"(?<![\w.>])%s\b" % re.escape(v), mb) if not dl_lo <= m.start() < dl_hi]
+        if not occ:
+            return None
+        defs = []
+        for p in occ:
+            after, before = mb[p + len(v):], mb[:p].rstrip()
+            if re.match(r"\s*(?:\+\+|--|[-+*/%&|^]=|<<=|>>=)", after) or before.endswith(("++", "--", "&")):
+                return None
+            if re.match(r"\s*=(?!=)", after):
+                semi = mb.find(";", p)
+                if semi < 0 or re.search(r"(?<![\w.>])%s\b" % re.escape(v), mb[p + len(v):semi]):
+                    return None
+                if before and not before.endswith((";", "{", "}")) and not re.search(r"\)\s*$", before):
+                    return None                              # an assignment inside an expression, not a statement
+                defs.append(p)
+        if len(defs) < 2 or occ[0] != defs[0]:
+            return None
+        if re.search(r"[{}]", mb[defs[0]:defs[-1]]) or _CTRL.search(mb[defs[0]:defs[-1]]):
+            return None
+        if _LOOPISH.search(mb[defs[0]:occ[-1]]):
+            return None
+        names = []
+        for k in range(2, len(defs) + 1):
+            n = f"{v}{k}"
+            if n in idents or n in names:
+                n = f"{v}_{k}"
+            if n in idents or n in names:
+                return None
+            names.append(n)
+        return dl_i, defs, occ, names
+
+    def apply(vs, src_lines, src_body):
+        edits = []                                          # (start, end, replacement) inside the body
+        decl_edits = {}
+        for v in vs:
+            dl_i, defs, occ, names = plans[v]
+            bounds = defs[1:] + [len(src_body)]
+            for k, (a, b) in enumerate(zip(defs[1:], bounds[1:])):
+                for p in occ:
+                    if a <= p < b:
+                        edits.append((p, p + len(v), names[k]))
+            decl_edits.setdefault(dl_i, []).append((v, names))
+        new = src_body
+        for a, b, r in sorted(edits, reverse=True):
+            new = new[:a] + r + new[b:]
+        nl = new.split("\n")
+        for dl_i, items in decl_edits.items():
+            j = dl_i - lo
+            for v, names in items:
+                nl[j] = re.sub(r"(?<![\w.>])%s\b" % re.escape(v), ", ".join([v] + names), nl[j], count=1)
+        return head + "\n".join(nl) + tail
+
+    plans = {}
+    for v in decls:
+        p = plan(v)
+        if p:
+            plans[v] = p
+    out = [(f"split {v} into {len(plans[v][1])}", apply([v], lines, body)) for v in plans]
+    if len(plans) > 1:
+        out.append((f"split ALL {'+'.join(plans)}", apply(list(plans), lines, body)))
+    return out
+
+
+ALL_FAMILIES = ("R2", "R3", "R4", "R5", "R6", "R7", "R8", "R9", "R10", "R12", "R13", "R14", "R15", "R16", "R17", "R18", "R19", "R20", "R21", "R22", "R23")
 RUNG_R_FAMILIES = ("R2", "R3", "R4", "R5", "R6", "R7")     # the free sweep's set (R8/R9 are the search engine's until measured)
 
 
@@ -2904,6 +3016,9 @@ def recipe_candidates(text, tu, fn, names, limit=24, rng=None, cap=40, blocks=Tr
     if "R22" in fam:
         for desc, cand in merge_walked_pointers(text, tu, fn, d_):
             out.append(("R22", desc, cand))
+    if "R23" in fam:
+        for desc, cand in split_reused_locals(text, tu, fn, d_):
+            out.append(("R23", desc, cand))
     if blocks and "R7" in fam:                            # last: one candidate per statement, so the targeted recipes go first
         for desc, cand in block_wraps(text, tu, fn, d_):
             out.append(("R7", desc, cand))
@@ -3887,6 +4002,33 @@ def selftest():
                                  next(r for r in sc.scan_text(bad, "src/fx/w.c", shared_defs=None) if r["form"] == "def")):
             fail(f"R22 must refuse {why}")
 
+    # R23, one name per value (T7 agents c1/c8, P36 S103; known-true: on each agent's own start text R23's joint split
+    # scores exactly the number the agent measured for that move alone — 12 for func_80135168, 26 for func_80135004).
+    RFIX = ("void func_80100000(s16 *p1, s16 *p2, s16 *q) {\n"
+            "    /* a note that\n"
+            "       spans lines */\n"
+            "    u16 a, b;\n"
+            "\n"
+            "    a = p2[0]; q[0] = a; b = p1[0]; q[1] = a - b;\n"
+            "    a = p2[1]; q[2] = a; b = p1[1]; q[3] = a - b;\n"
+            "}")
+    dR = next(r for r in sc.scan_text(RFIX, "src/fx/r.c", shared_defs=None) if r["form"] == "def")
+    r23 = dict(split_reused_locals(RFIX, "src/fx/r.c", "func_80100000", dR))
+    if sorted(r23) != ["split ALL a+b", "split a into 2", "split b into 2"]:
+        fail(f"R23 must offer each reused local and the joint split (past a multi-line comment), got {sorted(r23)}")
+    else:
+        j = r23["split ALL a+b"]
+        if "u16 a, a2, b, b2;" not in j or "a2 = p2[1]; q[2] = a2; b2 = p1[1]; q[3] = a2 - b2;" not in j \
+                or "a = p2[0]; q[0] = a; b = p1[0]; q[1] = a - b;" not in j:
+            fail(f"R23's joint split must rename every later segment and declare the names: {j!r}")
+    # controls: a compound write, and a loop between the definitions, each refuse the split
+    for bad, why in ((RFIX.replace("q[3] = a - b;", "q[3] = a - b; a += 1;"), "a compound write"),
+                     (RFIX.replace("    a = p2[1];", "    while (*q) q++;\n    a = p2[1];"), "a loop between the definitions")):
+        got = dict(split_reused_locals(bad, "src/fx/r.c", "func_80100000",
+                                       next(r for r in sc.scan_text(bad, "src/fx/r.c", shared_defs=None) if r["form"] == "def")))
+        if "split a into 2" in got:
+            fail(f"R23 must refuse {why}: {sorted(got)}")
+
     # the oracle's crash classification on its real message forms (R103)
     if not oracle.SIGNAL_LINE.search("bash: line 1: 3845091 Done   mipsel-linux-gnu-cpp ...\n     3845092 Aborted                 (core dumped) | tools/bin/gcc-2.7.2-psx/cc1 -quiet\n"):
         fail("SIGNAL_LINE must match bash's job-status block")
diff --git a/tools/delever_search.py b/tools/delever_search.py
index e2bc666ac3..a29f0d92cd 100644
--- a/tools/delever_search.py
+++ b/tools/delever_search.py
@@ -88,17 +88,17 @@ FAMILIES = {
     # R15 (the sink) is the arm-scoped form of the same tie: a value set in every arm of an if/else chain is a CROSS-BLOCK
     # pseudo local-alloc never gives a quantity, so the arm holds two quantities and takes block_alloc's unrolled case 2;
     # sinking makes it three, and case 3 falls through into case 2 and undoes its own exchange (T7 agent a1, func_80156044).
-    "REG-caller": ("R19", "R21", "R6", "R20", "R16", "R8", "R15", "R17", "R5", "R18", "R10", "R12", "R14", "R13", "R3", "R7", "R9", "R2", "R4", "R22"),
+    "REG-caller": ("R19", "R23", "R21", "R6", "R20", "R16", "R8", "R15", "R17", "R5", "R18", "R10", "R12", "R14", "R13", "R3", "R7", "R9", "R2", "R4", "R22"),
     # the s-bank order is global.c's allocno_compare (ref weight x live length), declaration order only on an exact tie
-    "REG-callee": ("R19", "R21", "R20", "R2", "R4", "R3", "R6", "R16", "R8", "R15", "R18", "R12", "R7", "R9", "R17", "R10", "R14", "R13", "R5", "R22"),
-    "REG-mixed": ("R19", "R21", "R6", "R20", "R16", "R2", "R15", "R17", "R18", "R5", "R10", "R4", "R3", "R8", "R12", "R13", "R14", "R7", "R9", "R22"),
+    "REG-callee": ("R19", "R23", "R21", "R20", "R2", "R4", "R3", "R6", "R16", "R8", "R15", "R18", "R12", "R7", "R9", "R17", "R10", "R14", "R13", "R5", "R22"),
+    "REG-mixed": ("R19", "R23", "R21", "R6", "R20", "R16", "R2", "R15", "R17", "R18", "R5", "R10", "R4", "R3", "R8", "R12", "R13", "R14", "R7", "R9", "R22"),
     # a copy dies to cse's canon_reg or the local-alloc tie unless its destination changes MODE (the width); an address
     # pseudo lives when a pointer local is used twice; a value named once is computed once; a short PARAMETER is extended in place
-    "COUNT": ("R19", "R22", "R21", "R20", "R12", "R16", "R14", "R15", "R6", "R8", "R3", "R18", "R7", "R17", "R5", "R13", "R9", "R10", "R2", "R4"),
+    "COUNT": ("R19", "R22", "R21", "R20", "R12", "R16", "R14", "R15", "R6", "R8", "R3", "R18", "R7", "R17", "R5", "R13", "R9", "R10", "R2", "R4", "R23"),
     # statement order IS the schedule among equal-priority insns (rank_for_schedule's LUID tie-break); do-while is a barrier
     # R17 is the DIRECTED form of the run-split R9 reaches only by luck: agent a2 measured 2,271 compiles for R9 to find it
     # in func_80168828 and R16+R17 reproduce the same close in ten.
-    "ORDER": ("R19", "R17", "R18", "R20", "R21", "R9", "R7", "R13", "R3", "R16", "R6", "R8", "R5", "R12", "R14", "R10", "R15", "R2", "R4", "R22"),
+    "ORDER": ("R19", "R17", "R18", "R20", "R21", "R9", "R7", "R13", "R3", "R16", "R6", "R8", "R5", "R12", "R14", "R10", "R15", "R2", "R4", "R22", "R23"),
     "MIXED": dl.ALL_FAMILIES,
     "OTHER": dl.ALL_FAMILIES,
 }
diff --git a/tools/verbatim_check.py b/tools/verbatim_check.py
index 46bfb2f33e..66e9fbb407 100644
--- a/tools/verbatim_check.py
+++ b/tools/verbatim_check.py
@@ -243,8 +243,12 @@ def main():
             keep.append(dict(binary=b, fn=fn, addr=None, nins=None, cls='UNCLASSIFIED',
                              disposition='UNKNOWN', form=form_of.get((b, fn), 'file-scope'), unit_entry=fn, unit_nins=None,
                              path=found_k[(b, fn)], why='added by --update; NEEDS CLASSIFICATION'))
-        man['rows'] = sorted(keep, key=lambda r: (r['binary'], r['fn']))
-        json.dump(man, open(MANIFEST, 'w'), indent=1)
+        # the manifest's row ORDER and its non-ASCII text (§, —, ·) are part of the file: the first --update of P36 S103
+        # re-sorted every row and escaped every character, a 588-line diff for one removed row. Keep the order, append
+        # the new rows, write UTF-8 as it was written (R57 — the instrument's write path is part of the instrument).
+        man['rows'] = keep
+        with open(MANIFEST, 'w') as fh:
+            fh.write(json.dumps(man, indent=1, ensure_ascii=False) + '\n')
         print(f'\nmanifest updated: {len(rows)} -> {len(man["rows"])} rows '
               f'({len(new)} added as UNCLASSIFIED — classify them)')
     if a.strict and (new or gone or moved):