mirror of
https://github.com/Druthulu/BFM-decomp
synced 2026-09-26 13:33:34 -04:00
phase-36: T7 agent a7 — func_801287B8 closed lever-free: a truncated local extern was faking a $4 pin (127 bodies)
A new class, and the cheapest one found so far. ov_SC04_011.c:197 declares extern void func_8013BC7C(void); while that function's real byte-verified definition, src/shared/ov/func_8013BC7C__8042ae05.h:3, is void func_8013BC7C(void *arg0). The $a0 instruction the pin was forcing is the argument the TU's own declaration denies. - the move: a block-local s32 *p = &D_801F1640; tested and passed through a function-pointer cast, ((void (*)(void *))func_8013BC7C)(p); — the idiom this TU already uses for two other calls. Score 0 on the first spelling tried, where seven mechanical runs and 4,000+ compiles had sat at 3, because every generator rewrites statements already present and this move adds an argument. - mechanism, both halves proven on bytes: update_equiv_regs (local-alloc.c:947, the referenced-exactly-twice test at :1066, substitution at :1085-1112) — the second reference keeps the address in a register, which is what the volatile was faking; and combine_regs (local-alloc.c:1722, hard-reg path :1797-1818) records $4 in qty_phys_copy_sugg so find_free_reg (:2073, restricted at :2145-2150) colours the quantity $4, which is what the pin was faking. Controls: reading the global directly scores 9; declaring the pointer at function top scores 4. - unlike agent a2's case this truncation is a LOCAL extern, so the cast keeps the bank body-only. delever --apply-body: ... IDENTICAL on 1 object(s) — KEPT, ledgered (rung E, a7) delever --propagate: 126 of 126 sibling(s) banked, 0 refused lever_census --check: 29,013 pin/asm sites, 29,013 marked !FAKE, 0 UNMARKED — OK - the R22 fleet gate is deferred until the burst of 20 agents drains: make clean deletes the build/ baseline object that every live --try scores against. Banking and propagation only read build/, so the writing lane runs beside the agents. - snapshot row 18.
This commit is contained in:
+12
-12
@@ -1,16 +1,16 @@
|
||||
rank fn alias copies best needed kinds regs tu
|
||||
1 func_801397B0 ov_SC04_011 126 2 1 pin $4 src/ov_SC04_011/ov_SC04_011_jr_801380E0.c
|
||||
2 func_8016C49C ov_SC04_011 126 2 1 pin $17 src/ov_SC04_011/ov_SC04_011_jr_8016AB6C.c
|
||||
3 func_80136334 ov_SC04_011 126 2 4 barrier,keepalive,launder,pin $12 src/ov_SC04_011/ov_SC04_011_jr_80135D20.c
|
||||
4 func_80136824 ov_SC04_011 126 2 6 barrier,keepalive,launder,pin $12,$5 src/ov_SC04_011/ov_SC04_011_jr_80135D20.c
|
||||
5 func_8016B234 ov_SC04_011 129 3 2 pin $16,$3 src/ov_SC04_011/ov_SC04_011_jr_8016AB6C.c
|
||||
6 func_801287B8 ov_SC04_011 127 3 1 pin $4 src/ov_SC04_011/ov_SC04_011.c
|
||||
7 func_80178970 ov_SC04_011 127 3 1 pin $2 src/ov_SC04_011/ov_SC04_011_jr_801734BC.c
|
||||
8 func_8015FBE0 ov_SC04_011 125 3 1 barrier src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c
|
||||
9 func_8017A3D8 ov_SC04_011 118 3 1 pin $4 src/ov_SC04_011/ov_SC04_011_jr_80178D40.c
|
||||
10 func_80148E54 ov_SC04_011 132 4 2 launder,pin $4 src/ov_SC04_011/ov_SC04_011_after.c
|
||||
11 func_80157D20 ov_SC04_011 132 4 2 pin $4,$5 src/ov_SC04_011/ov_SC04_011_jr_80154C24.c
|
||||
12 func_801627E8 ov_SC04_011 132 4 2 launder,pin $4 src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c
|
||||
1 func_80136824 ov_SC01_000 125 0 6 barrier,keepalive,launder,pin $12,$5 src/ov_SC01_000/ov_SC01_000_jr_80135D20.c
|
||||
2 func_8016C49C ov_SC04_011 126 1 1 pin $17 src/ov_SC04_011/ov_SC04_011_jr_8016AB6C.c
|
||||
3 func_801397B0 ov_SC04_011 126 2 1 pin $4 src/ov_SC04_011/ov_SC04_011_jr_801380E0.c
|
||||
4 func_80136334 ov_SC04_011 126 2 4 barrier,keepalive,launder,pin $12 src/ov_SC04_011/ov_SC04_011_jr_80135D20.c
|
||||
5 func_801627E8 ov_SC04_011 132 3 2 launder,pin $4 src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c
|
||||
6 func_8016B234 ov_SC04_011 129 3 2 pin $16,$3 src/ov_SC04_011/ov_SC04_011_jr_8016AB6C.c
|
||||
7 func_801287B8 ov_SC04_011 127 3 1 pin $4 src/ov_SC04_011/ov_SC04_011.c
|
||||
8 func_80178970 ov_SC04_011 127 3 1 pin $2 src/ov_SC04_011/ov_SC04_011_jr_801734BC.c
|
||||
9 func_8015FBE0 ov_SC04_011 125 3 1 barrier src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c
|
||||
10 func_8017A3D8 ov_SC04_011 118 3 1 pin $4 src/ov_SC04_011/ov_SC04_011_jr_80178D40.c
|
||||
11 func_80148E54 ov_SC04_011 132 4 2 launder,pin $4 src/ov_SC04_011/ov_SC04_011_after.c
|
||||
12 func_80157D20 ov_SC04_011 132 4 2 pin $4,$5 src/ov_SC04_011/ov_SC04_011_jr_80154C24.c
|
||||
13 func_80139BE0 ov_SC04_011 129 4 1 launder src/ov_SC04_011/ov_SC04_011_jr_801380E0.c
|
||||
14 func_80166F58 ov_SC04_011 125 4 5 launder,pin $20,$5 src/ov_SC04_011/ov_SC04_011_jr_8015C32C.c
|
||||
15 func_80143D28 ov_SC04_011 131 5 1 pin $18 src/ov_SC04_011/ov_SC04_011_jr_80140608.c
|
||||
|
||||
|
@@ -0,0 +1,79 @@
|
||||
s32 func_80136824(s32 arg0, s32 arg1, s32 arg2) {
|
||||
extern u8 D_801152A8[];
|
||||
extern s16 D_801152AA;
|
||||
extern s16 D_801152AC;
|
||||
extern s16 D_80126722;
|
||||
extern s16 D_80126724;
|
||||
|
||||
u16 *ac;
|
||||
s16 *b8;
|
||||
s16 *b4;
|
||||
s32 r;
|
||||
s32 pos;
|
||||
s32 a1v;
|
||||
s16 temp_v0;
|
||||
s16 temp_v1;
|
||||
s32 var_a3;
|
||||
s16 var_v0_3;
|
||||
s32 temp_a1;
|
||||
s32 var_t0;
|
||||
s32 var_v1;
|
||||
s16 *b4b;
|
||||
u16 *p;
|
||||
|
||||
a1v = arg1;
|
||||
pos = arg2;
|
||||
if (!(a1v & 1)) {
|
||||
var_t0 = (s16) arg2 - (*(s16 **)&D_8017F198)[1];
|
||||
var_v1 = var_t0;
|
||||
var_a3 = -(*(s16 **)&D_8017F1A4)[1];
|
||||
} else {
|
||||
var_a3 = (*(s16 **)&D_8017F1A4)[1];
|
||||
var_v1 = (*(s16 **)&D_8017F198)[1] - (s16) arg2;
|
||||
var_t0 = -var_v1;
|
||||
}
|
||||
b8 = (*(s16 **)&D_8017F1A4);
|
||||
ac = (*(u16 **)&D_8017F198);
|
||||
b4 = D_8017F1A0;
|
||||
temp_a1 = -var_v1;
|
||||
r = (temp_a1 * b8[0]) / var_a3;
|
||||
b4[0] = ac[0] + r;
|
||||
b4[1] = ac[1] + var_t0;
|
||||
r = (temp_a1 * b8[2]) / var_a3;
|
||||
temp_v0 = ac[2] + r;
|
||||
b4[2] = temp_v0;
|
||||
temp_v1 = b4[0];
|
||||
if (temp_v1 < M2C_FIELD(((void *)arg0), s16 *, 4)) {
|
||||
return 0;
|
||||
}
|
||||
if (M2C_FIELD(((void *)arg0), s16 *, 6) < temp_v1) {
|
||||
return 0;
|
||||
}
|
||||
if (temp_v0 < M2C_FIELD(((void *)arg0), s16 *, 0xC)) {
|
||||
return 0;
|
||||
}
|
||||
if (M2C_FIELD(((void *)arg0), s16 *, 0xE) < temp_v0) {
|
||||
return 0;
|
||||
}
|
||||
if (arg1 & 0x8000) {
|
||||
p = (*(u16 **)&D_8017F19C);
|
||||
b4[0] = (s16) p[0];
|
||||
b4[2] = (s16) p[2];
|
||||
}
|
||||
D_801152AC = 0;
|
||||
(*(s16 *)D_801152A8) = 0;
|
||||
if (arg1 & 1) {
|
||||
b4b = D_8017F1A0;
|
||||
D_801152AA = 0xFFF;
|
||||
var_v0_3 = pos + 2;
|
||||
} else {
|
||||
b4b = D_8017F1A0;
|
||||
D_801152AA = -0xFFF;
|
||||
var_v0_3 = pos - 2;
|
||||
}
|
||||
b4b[1] = var_v0_3;
|
||||
(*(s16 *)D_80126720) = (s16) ((s32) (M2C_FIELD(((void *)arg0), s16 *, 4) + M2C_FIELD(((void *)arg0), s16 *, 6)) >> 1);
|
||||
D_80126722 = (s16) ((s32) (M2C_FIELD(((void *)arg0), s16 *, 8) + M2C_FIELD(((void *)arg0), s16 *, 0xA)) >> 1);
|
||||
D_80126724 = (s16) ((s32) (M2C_FIELD(((void *)arg0), s16 *, 0xC) + M2C_FIELD(((void *)arg0), s16 *, 0xE)) >> 1);
|
||||
return 1;
|
||||
}
|
||||
@@ -0,0 +1,82 @@
|
||||
s32 func_80136824(s32 arg0, s32 arg1, s32 arg2) {
|
||||
extern u8 D_801152A8[];
|
||||
extern s16 D_801152AA;
|
||||
extern s16 D_801152AC;
|
||||
extern s16 D_80126722;
|
||||
extern s16 D_80126724;
|
||||
|
||||
u16 *ac;
|
||||
s16 *b8;
|
||||
s16 *b4;
|
||||
s32 r;
|
||||
register s32 pos __asm__("$12"); // !FAKE: pin $12 — NEEDED DIFFERS (P36 rung A tus1)
|
||||
register s32 a1v __asm__("$5"); // !FAKE: pin $5 — NEEDED DIFFERS (P36 rung A tus1)
|
||||
s16 temp_v0;
|
||||
s16 temp_v1;
|
||||
s32 var_a3;
|
||||
s16 var_v0_3;
|
||||
s32 temp_a1;
|
||||
s32 var_t0;
|
||||
s32 var_v1;
|
||||
s16 *b4b;
|
||||
u16 *p;
|
||||
|
||||
__asm__ ("" : "=r"(a1v) : "0"(arg1)); // !FAKE: launder — NEEDED DIFFERS (P36 rung A tus1)
|
||||
pos = arg2;
|
||||
if (!(a1v & 1)) {
|
||||
var_t0 = (s16) arg2 - (*(s16 **)&D_8017F198)[1];
|
||||
var_v1 = var_t0;
|
||||
var_a3 = -(*(s16 **)&D_8017F1A4)[1];
|
||||
} else {
|
||||
var_a3 = (*(s16 **)&D_8017F1A4)[1];
|
||||
var_v1 = (*(s16 **)&D_8017F198)[1] - (s16) arg2;
|
||||
var_t0 = -var_v1;
|
||||
}
|
||||
b8 = (*(s16 **)&D_8017F1A4);
|
||||
ac = (*(u16 **)&D_8017F198);
|
||||
b4 = D_8017F1A0;
|
||||
temp_a1 = -var_v1;
|
||||
r = (temp_a1 * b8[0]) / var_a3;
|
||||
b4[0] = ac[0] + r;
|
||||
b4[1] = ac[1] + var_t0;
|
||||
r = (temp_a1 * b8[2]) / var_a3;
|
||||
temp_v0 = ac[2] + r;
|
||||
b4[2] = temp_v0;
|
||||
temp_v1 = b4[0];
|
||||
if (temp_v1 < M2C_FIELD(((void *)arg0), s16 *, 4)) {
|
||||
return 0;
|
||||
}
|
||||
if (M2C_FIELD(((void *)arg0), s16 *, 6) < temp_v1) {
|
||||
return 0;
|
||||
}
|
||||
if (temp_v0 < M2C_FIELD(((void *)arg0), s16 *, 0xC)) {
|
||||
return 0;
|
||||
}
|
||||
if (M2C_FIELD(((void *)arg0), s16 *, 0xE) < temp_v0) {
|
||||
return 0;
|
||||
}
|
||||
if (arg1 & 0x8000) {
|
||||
p = (*(u16 **)&D_8017F19C);
|
||||
b4[0] = (s16) p[0];
|
||||
b4[2] = (s16) p[2];
|
||||
}
|
||||
D_801152AC = 0;
|
||||
(*(s16 *)D_801152A8) = 0;
|
||||
if (arg1 & 1) {
|
||||
b4b = D_8017F1A0;
|
||||
D_801152AA = 0xFFF;
|
||||
__asm__ __volatile__(""); // !FAKE: barrier — NEEDED DIFFERS (P36 rung A tus1)
|
||||
var_v0_3 = pos + 2;
|
||||
} else {
|
||||
b4b = D_8017F1A0;
|
||||
D_801152AA = -0xFFF;
|
||||
__asm__ __volatile__(""); // !FAKE: barrier — NEEDED DIFFERS (P36 rung A tus1)
|
||||
var_v0_3 = pos - 2;
|
||||
}
|
||||
b4b[1] = var_v0_3;
|
||||
__asm__ __volatile__("" :: "r"(pos)); // !FAKE: keepalive — NEEDED DIFFERS (P36 rung A tus1)
|
||||
(*(s16 *)D_80126720) = (s16) ((s32) (M2C_FIELD(((void *)arg0), s16 *, 4) + M2C_FIELD(((void *)arg0), s16 *, 6)) >> 1);
|
||||
D_80126722 = (s16) ((s32) (M2C_FIELD(((void *)arg0), s16 *, 8) + M2C_FIELD(((void *)arg0), s16 *, 0xA)) >> 1);
|
||||
D_80126724 = (s16) ((s32) (M2C_FIELD(((void *)arg0), s16 *, 0xC) + M2C_FIELD(((void *)arg0), s16 *, 0xE)) >> 1);
|
||||
return 1;
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
g3: verdict NO-MATCH start 21 best 10 compiles 808 path R12 width pos s32->u16 @1113 + R7 do-while @1168
|
||||
g5: verdict NO-MATCH start 21 best 4 compiles 2316 path R12 width pos s32->u16 @1109 + R7 do-while @1164 + R7 do-while @1163 + R14 param-width arg1 s32->s16 @1098
|
||||
s1: verdict NO-MATCH start 21 best 2 compiles 188 path R15 sink @1171 (var_v0_3) + R12 width pos s32->u16 @1109
|
||||
s2: verdict NO-MATCH start 21 best 2 compiles 188 path R15 sink @1171 (var_v0_3) + R12 width pos s32->u16 @1109
|
||||
s4: verdict BANK-REFUSED start 21 best 0 compiles 288 path R15 sink @1171 (var_v0_3) + R12 width pos s32->u16 @1109 + R14 param-width arg1 s32->s16 @1098
|
||||
s7: verdict NO-MATCH start 21 best 2 compiles 554 path R15 sink @1174 (var_v0_3) + R12 width pos s32->u16 @1112
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R12 width pos s32->u16 @1112 -> 2 [REG] (from 11)
|
||||
R12 width pos s32->s16 @1112 -> 2 [REG] (from 11)
|
||||
R6 inline a1v @1123 -> 2 [REG] (from 2)
|
||||
R8 hoist tmp0 @1126 -> 2 [REG] (from 2)
|
||||
R5 swap + @1139 -> 2 [REG] (from 2)
|
||||
R18 bystander @1134->1137 -> 2 [REG] (from 2)
|
||||
R12 width r s32->u16 @1111 -> 2 [REG] (from 2)
|
||||
R7 block @1123 -> 2 [REG] (from 2)
|
||||
R9 swap-stmts @1123 -> 2 [REG] (from 2)
|
||||
R2 decl-order 1,0 -> 2 [REG] (from 2)
|
||||
R4 decl-move pos 9->0 -> 2 [REG] (from 2)
|
||||
R8 hoist tmp0 @1126 -> 2 [REG] (from 2)
|
||||
@@ -0,0 +1,35 @@
|
||||
src/ov_SC01_000/ov_SC01_000_jr_80135D20.c:func_80136824: score 21 (COUNT; mine 154 ins, target 156) — not yet
|
||||
register pairs (mine -> target, count): t4->t3 x4, v0->a1 x2, t3->a2 x2, t4->a1 x1, t3->t4 x1
|
||||
replace mine[1:6] target[1:6]
|
||||
1 move t4,a1 | move t3,a1
|
||||
2 andi v0,t4,0x1 | andi a1,a1,0x1
|
||||
3 bnez v0,b48 <func_80136824+0x44> | bnez a1,b48 <func_80136824+0x44>
|
||||
4 move t3,a2 | move t4,a2
|
||||
5 sll v0,t3,0x10 | sll v0,a2,0x10
|
||||
replace mine[22:23] target[22:23]
|
||||
22 sll v0,t3,0x10 | sll v0,a2,0x10
|
||||
replace mine[83:84] target[83:84]
|
||||
83 bnez v0,d64 <func_80136824+0x260> | bnez v0,d6c <func_80136824+0x268>
|
||||
replace mine[88:89] target[88:89]
|
||||
88 bnez v0,d64 <func_80136824+0x260> | bnez v0,d6c <func_80136824+0x268>
|
||||
replace mine[94:95] target[94:95]
|
||||
94 bnez v0,d64 <func_80136824+0x260> | bnez v0,d6c <func_80136824+0x268>
|
||||
replace mine[99:100] target[99:100]
|
||||
99 bnez v0,d64 <func_80136824+0x260> | bnez v0,d6c <func_80136824+0x268>
|
||||
replace mine[101:102] target[101:102]
|
||||
101 andi v0,t4,0x8000 | andi v0,t3,0x8000
|
||||
replace mine[103:104] target[103:104]
|
||||
103 andi v0,t4,0x1 | andi v0,t3,0x1
|
||||
replace mine[113:114] target[113:114]
|
||||
113 andi v0,t4,0x1 | andi v0,t3,0x1
|
||||
replace mine[118:120] target[118:120]
|
||||
118 beqz v0,cf4 <func_80136824+0x1f0> | beqz v0,cfc <func_80136824+0x1f8>
|
||||
119 addiu a0,t3,2 | li v0,4095
|
||||
replace mine[122:125] target[122:126]
|
||||
122 j d04 <func_80136824+0x200> | lui at,0x0
|
||||
123 li v0,4095 | sh v0,0(at)
|
||||
124 addiu a0,t3,-2 | j d14 <func_80136824+0x210>
|
||||
125 -- | addiu v0,t4,2
|
||||
replace mine[130:131] target[131:133]
|
||||
130 sh a0,2(v1) | addiu v0,t4,-2
|
||||
131 -- | sh v0,2(v1)
|
||||
@@ -0,0 +1,10 @@
|
||||
REMOVED pin $4 line 1115
|
||||
REMOVED pin $6 line 1116
|
||||
REMOVED pin $9 line 1117
|
||||
REMOVED pin $3 line 1118
|
||||
NEEDED pin $12 line 1119
|
||||
NEEDED pin $5 line 1120
|
||||
NEEDED launder line 1131
|
||||
NEEDED barrier line 1175
|
||||
NEEDED barrier line 1180
|
||||
NEEDED keepalive line 1184
|
||||
@@ -0,0 +1,2 @@
|
||||
src/ov_SC01_000/ov_SC01_000_jr_80135D20.c
|
||||
func_80136824
|
||||
@@ -0,0 +1,30 @@
|
||||
void func_801287B8(void) {
|
||||
func_80129CF8();
|
||||
func_8017849C();
|
||||
((void (*)(void *))func_8014FDF4)(&D_80126B58);
|
||||
((void (*)(void *))func_801505FC)(&D_80126B58);
|
||||
func_801508B4(&D_80126B58);
|
||||
func_80165E90();
|
||||
func_801627E8();
|
||||
func_80162B1C();
|
||||
func_80165CA0();
|
||||
func_80129010();
|
||||
func_8013CA14();
|
||||
func_800190AC();
|
||||
func_8012956C();
|
||||
func_8016E95C();
|
||||
func_801754A8();
|
||||
{
|
||||
s32 *p = &D_801F1640;
|
||||
|
||||
if (*p == 0) {
|
||||
((void (*)(void *))func_8013BC7C)(p);
|
||||
}
|
||||
}
|
||||
func_8013BCDC();
|
||||
func_801379FC();
|
||||
D_800B99DA++;
|
||||
if (D_800B9A64 != 0) {
|
||||
func_8001212C();
|
||||
}
|
||||
}
|
||||
@@ -3,16 +3,18 @@ g4s: verdict NO-MATCH start 3 best 3 compiles 674 path
|
||||
g5: verdict NO-MATCH start 3 best 3 compiles 1234 path
|
||||
s1: verdict NO-MATCH start 3 best 3 compiles 189 path
|
||||
s2: verdict NO-MATCH start 3 best 3 compiles 189 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R6 inline p @222 -> 3 (from 3)
|
||||
R7 block @218 -> 3 (from 3)
|
||||
R7 do-while @218 -> 3 (from 3)
|
||||
R7 block @217 -> 3 (from 3)
|
||||
R7 do-while @217 -> 3 (from 3)
|
||||
R7 block @216 -> 3 (from 3)
|
||||
R7 do-while @216 -> 3 (from 3)
|
||||
R7 block @224 -> 3 (from 3)
|
||||
R7 do-while @224 -> 3 (from 3)
|
||||
R7 block @215 -> 3 (from 3)
|
||||
R7 do-while @215 -> 3 (from 3)
|
||||
R7 block @214 -> 3 (from 3)
|
||||
s4: verdict NO-MATCH start 3 best 3 compiles 440 path
|
||||
s7: verdict NO-MATCH start 3 best 3 compiles 561 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R6 inline p @222 -> 3 [COUNT] (from 3)
|
||||
R7 block @218 -> 3 [REG] (from 3)
|
||||
R7 do-while @218 -> 3 [REG] (from 3)
|
||||
R7 block @217 -> 3 [REG] (from 3)
|
||||
R7 do-while @217 -> 3 [REG] (from 3)
|
||||
R7 block @216 -> 3 [REG] (from 3)
|
||||
R7 do-while @216 -> 3 [REG] (from 3)
|
||||
R7 block @224 -> 3 [REG] (from 3)
|
||||
R7 do-while @224 -> 3 [REG] (from 3)
|
||||
R7 block @215 -> 3 [REG] (from 3)
|
||||
R7 do-while @215 -> 3 [REG] (from 3)
|
||||
R7 block @214 -> 3 [REG] (from 3)
|
||||
|
||||
@@ -0,0 +1,106 @@
|
||||
# func_801287B8 (src/ov_SC04_011/ov_SC04_011.c) — score 0, byte-identical, lever-free
|
||||
|
||||
Levers removed: the one NEEDED site, `register volatile s32 *p __asm__("$4")` (line 222) — the `$4` pin AND the
|
||||
`volatile` are both gone. No `asm`, no pin, no added `volatile`, no `__builtin_*`.
|
||||
|
||||
## (a) The residual in one sentence
|
||||
|
||||
`v0 -> a0 x4`, 62 ins vs 62, one 3-instruction block: mine materialised the address of `D_801F1640` into `$v0`
|
||||
(`lui v0; addiu v0; lw v0,0(v0)`), the target into `$a0` (`lui a0; addiu a0; lw v0,0(a0)`) — i.e. the target's address
|
||||
pseudo carries an **argument-register copy preference**, which only exists if that address is passed to a call.
|
||||
|
||||
## (b) The reading: it is a DECLARATION artefact, and the pass says so
|
||||
|
||||
The prompt asked which of the two it is. **It is the declaration** — but not in the way a2's case was, and it is
|
||||
fixable body-only.
|
||||
|
||||
`ov_SC04_011.c:197` declares `extern void func_8013BC7C(void);`. The function's real, byte-verified definition is
|
||||
`src/shared/ov/func_8013BC7C__8042ae05.h:3`:
|
||||
|
||||
```c
|
||||
void func_8013BC7C(void *arg0) {
|
||||
extern void (*D_8017F230[])(void *);
|
||||
D_8017F230[((S_8013BC7C_8013BC7C *)arg0)->f68](arg0);
|
||||
}
|
||||
```
|
||||
|
||||
It takes a pointer and dispatches on it. The local extern had been truncated to `(void)`, so no C written against
|
||||
*this TU's* declaration could produce the `$a0` instruction — exactly a2's shape. The difference from a2's case is
|
||||
that the truncation is in a **local `extern` in this TU**, not a shared header, so a cast at the call site restores
|
||||
the argument without touching any declaration: the bank stays body-only.
|
||||
|
||||
Two decisions, both in `tools/reference/gcc-2.7.2/local-alloc.c`, and both are needed:
|
||||
|
||||
1. **Why the address stays in a register instead of folding into the `lw`.**
|
||||
`update_equiv_regs` (`local-alloc.c:947`) attaches a `REG_EQUIV` note carrying the `SYMBOL_REF` to the address
|
||||
pseudo, and only substitutes it back into its use when the register **"is referenced exactly twice, meaning it is
|
||||
set once and used once"** (`local-alloc.c:1066`; the replacement itself is the `REG_DEAD` scan at
|
||||
`local-alloc.c:1085-1112`, `validate_replace_rtx` + `reg_n_refs[regno] = 0`). One use folds to `lui;lw %lo`
|
||||
(2 insns). **Two** uses — the load base and the call argument — defeat that test, the pseudo survives, and the
|
||||
MIPS mover emits `lui;addiu` + `lw 0(reg)` (3 insns). This is what the old `volatile` was faking.
|
||||
|
||||
2. **Why the surviving pseudo lands in `$a0` and the `move` disappears.**
|
||||
The `move $4, pseudo` that sets up the call makes `combine_regs` (`local-alloc.c:1722`) take the
|
||||
"UREG is a hard reg and SREG is a pseudo" path at `local-alloc.c:1797-1818`: it does *not* tie them, it records
|
||||
`$4` in `qty_phys_copy_sugg[]` and returns 0 so the two lifetimes stay disjoint. `find_free_reg`
|
||||
(`local-alloc.c:2073`) then runs its `just_try_suggested` pass and restricts the candidate set to exactly those
|
||||
copy suggestions — `local-alloc.c:2145-2150`, `if (qty_phys_num_copy_sugg[qty] != 0) IOR_COMPL_HARD_REG_SET
|
||||
(first_used, qty_phys_copy_sugg[qty]);` — so the quantity is coloured `$4`, the copy is coalesced away, and the
|
||||
`lui/addiu` write `a0` directly. This is what the old `__asm__("$4")` pin was faking.
|
||||
|
||||
Both claims are **proved on bytes** by the controls in (e).
|
||||
|
||||
## (c) The move
|
||||
|
||||
- One move: give the block a plain `s32 *p = &D_801F1640;`, test `*p`, and pass `p` to `func_8013BC7C` through a
|
||||
function-pointer cast — `((void (*)(void *))func_8013BC7C)(p);` — the same idiom this TU already uses three lines
|
||||
up for `func_8014FDF4` / `func_801505FC`. The second reference to `p` supplies both the two-use count of (b1) and
|
||||
the `$4` copy suggestion of (b2); the pin and the `volatile` become redundant and are deleted.
|
||||
|
||||
`PACK/body.c` — score 0, first spelling tried.
|
||||
|
||||
## (d) GENERATOR PROPOSAL (new — not R15/R16/R17/R18)
|
||||
|
||||
**R19 "argument restore":** when the residual is REG-only and the mapping `mine -> target` sends one pseudo to an
|
||||
argument register `$4..$7`, look for a call in that block whose local `extern` prototype takes fewer parameters than
|
||||
the callee's real definition (the shared body under `src/shared/ov/<fn>__*.h`, or its declaration in any other TU —
|
||||
`tools/match_protos.py` / `tools/fix_arity_callers.py` already own that oracle), and offer the candidate that routes
|
||||
the nearby value into that call through a function-pointer cast `((R (*)(T))f)(v)`, hoisting the value into a local
|
||||
if it is currently spelled inline.
|
||||
|
||||
Generalised in one sentence: *when the diff is "a pseudo wants an argument register", the missing argument is real —
|
||||
recover the callee's true arity from the other TUs and pass the value.*
|
||||
|
||||
Two things make this cheap and safe to run fleet-wide: the arity mismatch is a **static, zero-compile filter** (a
|
||||
call spelled with fewer args than the callee's real definition is a defect regardless of bytes), and the fix is
|
||||
**body-only** whenever the truncated prototype is a local `extern` in the same TU. A scan of every function still
|
||||
holding a NEEDED `$4`/`$5`/`$6`/`$7` pin against the arity oracle should be run before any further search on them —
|
||||
this residual class is not an allocator puzzle at all.
|
||||
|
||||
## (e) What did NOT work, with byte evidence
|
||||
|
||||
- **Read the global directly and pass `&D_801F1640`** (`if (D_801F1640 == 0) ((void (*)(void *))func_8013BC7C)
|
||||
(&D_801F1640);`): **score 9 (COUNT), 63 ins vs 62**. The address then has one use each side of the branch, so
|
||||
`update_equiv_regs` folds the load to `lui v0; lw 0(v0)` and the argument is materialised separately — one insn
|
||||
too many. This is the control that proves decision (b1): the shared *local* is what creates the two references.
|
||||
- **The pointer declared at the top of the function** instead of in the inner block: **score 4 (MIXED), `s0 -> a0
|
||||
x4`**, with an extra `move a0,s0` where the target has a `nop`. Live across fifteen calls, the pseudo becomes a
|
||||
*global* allocno and takes a callee-saved `$s0`, so `find_free_reg`'s copy-suggestion pass never sees it. This is
|
||||
the control that proves decision (b2): the `$4` colour comes from a *block-local* quantity carrying the copy
|
||||
suggestion.
|
||||
- The mechanical search's 4,000+ compiles across seven runs (`history.txt`, best 3 every time) could not reach this:
|
||||
every generator it has rewrites statements that are already there, and this move had to **add an argument that the
|
||||
TU's own declaration says does not exist**. No amount of R6/R7/R9/R12 reshuffling can produce it.
|
||||
|
||||
## (f) Where the method fell short
|
||||
|
||||
Step 1 of the brief sends you to the compiler sources first. Here the compiler was innocent: the fastest possible
|
||||
first move was `grep -rn func_8013BC7C --include=*.h src/ include/`, which shows the real signature in one line.
|
||||
**The method should put a callee-arity check before the pass reading whenever the residual's differing register is an
|
||||
argument register** — `$4..$7` in the `register pairs` line is a strong prior for "a call is missing an argument",
|
||||
and it costs one grep. The pass reading was still worth doing afterwards, because it is what turned the fix into
|
||||
R19's applicability test (block-local, two references) rather than a lucky spelling.
|
||||
|
||||
Also worth recording for the coordinator: the more readable end state is to repair `ov_SC04_011.c:197` to
|
||||
`extern void func_8013BC7C(void *a0);` and drop the cast. That is a declaration change, outside the body-only bank,
|
||||
and it is **not** byte-proven here (`--try` substitutes only the body), though it compiles to the same RTL.
|
||||
@@ -0,0 +1,105 @@
|
||||
void func_8012956C(void) {
|
||||
|
||||
extern s16 D_80114EE0;
|
||||
extern u8 D_800B9A78;
|
||||
extern u8 D_801ED9C5[];
|
||||
extern u8 D_801ED9C6[];
|
||||
extern u8 D_801ED9C8[];
|
||||
extern u8 D_801ED9C9[];
|
||||
extern u8 D_801ED9CA[];
|
||||
extern u8 D_801F1620;
|
||||
extern u8 D_800AF630[];
|
||||
extern u8 D_800A6518[];
|
||||
s32 *sp10;
|
||||
u8 *afbase;
|
||||
s32 *sp0;
|
||||
Ent_956C *base;
|
||||
s32 i;
|
||||
s16 a1;
|
||||
u32 temp_a3;
|
||||
u32 arg0;
|
||||
u32 s;
|
||||
u32 s2;
|
||||
u32 t6;
|
||||
s32 code;
|
||||
|
||||
sp10 = (s32 *)0x1F800010;
|
||||
sp0 = (s32 *)0x1F800000;
|
||||
afbase = (u8 *)&D_800AF630;
|
||||
if (D_80114EE0 == 0) {
|
||||
return;
|
||||
}
|
||||
base = (Ent_956C *)&D_800B9A78;
|
||||
i = 0;
|
||||
do {
|
||||
s32 idx = i * 8 + 4;
|
||||
code = base->f34;
|
||||
if (code == 0x7FFE) {
|
||||
goto case_7FFE;
|
||||
}
|
||||
if (code < 0x7FFF) {
|
||||
a1 = i + 3;
|
||||
if (code == 0x7FFD) {
|
||||
goto case_7FFD;
|
||||
}
|
||||
goto do_default;
|
||||
}
|
||||
a1 = i + 3;
|
||||
if (code != 0x7FFF) {
|
||||
goto do_default;
|
||||
}
|
||||
goto next;
|
||||
case_7FFD:
|
||||
if (i == 0) {
|
||||
func_801299C8(D_801F1620, 1, base);
|
||||
}
|
||||
func_80015B6C(-0xA0, -0x74, 0x140, 0x8C,
|
||||
D_801ED9C8[0], D_801ED9C8[1], D_801ED9C8[2],
|
||||
D_801ED9C8[4], D_801ED9C8[5], D_801ED9C8[6]);
|
||||
func_80015B6C(-0xA0, 0x18, 0x140, 0x3C,
|
||||
D_801ED9C8[4], D_801ED9C8[5], D_801ED9C8[6],
|
||||
D_801ED9C8[8], D_801ED9C8[9], D_801ED9C8[0xA]);
|
||||
func_80015B6C(-0xA0, 0x54, 0x140, 0x28,
|
||||
D_801ED9C8[8], D_801ED9C8[9], D_801ED9C8[0xA],
|
||||
D_801ED9C8[0xC], D_801ED9C8[0xD], D_801ED9C8[0xE]);
|
||||
goto next;
|
||||
case_7FFE:
|
||||
func_801299C8(D_801F1620, (s16)(i * 2), base);
|
||||
func_80015B6C(-0xA0, *(s16 *)&base->f3A, 0x140, base->f3E,
|
||||
((u8 *)&D_801ED9C4)[idx], D_801ED9C5[idx], D_801ED9C6[idx],
|
||||
D_801ED9C8[idx], D_801ED9C9[idx], D_801ED9CA[idx]);
|
||||
goto next;
|
||||
do_default:
|
||||
arg0 = D_801F1620;
|
||||
s = base->f40;
|
||||
temp_a3 = base->f38;
|
||||
s += temp_a3;
|
||||
base->f1C = s;
|
||||
s2 = base->f42;
|
||||
t6 = base->f3A;
|
||||
s2 += t6;
|
||||
base->f1E = s2;
|
||||
((void (*)(s32, s32, void *, s32))func_801299C8)(arg0, a1, base, temp_a3);
|
||||
*(Blk16_956C *)sp0 = *(Blk16_956C *)base;
|
||||
{
|
||||
s32 *dst = sp10;
|
||||
s32 *src = (s32 *)((u8 *)base + 0x10);
|
||||
s32 *end = (s32 *)((u8 *)base + 0x30);
|
||||
do {
|
||||
*(Blk16_956C *)dst = *(Blk16_956C *)src;
|
||||
src += 4;
|
||||
dst += 4;
|
||||
} while (src != end);
|
||||
*dst = *src;
|
||||
sp10[5] = (s32)sp0;
|
||||
if (base->f36 == 0) {
|
||||
GsSortFastBg(sp10, &D_800A6518[(*(u16 *)(afbase + 0xA3D2)) * 0x14], base->f34, dst);
|
||||
} else {
|
||||
GsSortBg(sp10, &D_800A6518[(*(u16 *)(afbase + 0xA3D2)) * 0x14], base->f34, dst);
|
||||
}
|
||||
}
|
||||
next:
|
||||
base += 1;
|
||||
i += 1;
|
||||
} while (i < 2);
|
||||
}
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 11 best 11 compiles 806 path
|
||||
g5: verdict NO-MATCH start 11 best 6 compiles 2241 path R9 swap-stmts @557 + R7 do-while @556
|
||||
s1: verdict NO-MATCH start 11 best 11 compiles 185 path
|
||||
s2: verdict NO-MATCH start 11 best 11 compiles 185 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R6 inline arg0 @556 -> 11 (from 11)
|
||||
R9 swap-stmts @556 -> 11 (from 11)
|
||||
R2 decl-order 0,2,1 -> 11 (from 11)
|
||||
R4 decl-move temp_a3 16->0 -> 11 (from 11)
|
||||
R6 inline t6 @562 -> 11 (from 11)
|
||||
R9 swap-stmts @557 -> 11 (from 11)
|
||||
R2 decl-order 1,0,2 -> 11 (from 11)
|
||||
R4 decl-move temp_a3 16->1 -> 11 (from 11)
|
||||
R6 inline end @570 -> 11 (from 11)
|
||||
R7 block @550 -> 11 (from 11)
|
||||
R2 decl-order 1,2,0 -> 11 (from 11)
|
||||
R4 decl-move temp_a3 16->2 -> 11 (from 11)
|
||||
s4: verdict NO-MATCH start 11 best 11 compiles 431 path
|
||||
s7: verdict NO-MATCH start 11 best 11 compiles 550 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R6 inline arg0 @556 -> 11 [COUNT] (from 11)
|
||||
R9 swap-stmts @556 -> 11 [COUNT] (from 11)
|
||||
R2 decl-order 0,2,1 -> 11 [COUNT] (from 11)
|
||||
R4 decl-move temp_a3 16->0 -> 11 [COUNT] (from 11)
|
||||
R6 inline t6 @562 -> 11 [COUNT] (from 11)
|
||||
R18 bystander @556->559 -> 11 [COUNT] (from 11)
|
||||
R9 swap-stmts @557 -> 11 [COUNT] (from 11)
|
||||
R2 decl-order 1,0,2 -> 11 [COUNT] (from 11)
|
||||
R4 decl-move temp_a3 16->1 -> 11 [COUNT] (from 11)
|
||||
R6 inline end @570 -> 11 [COUNT] (from 11)
|
||||
R18 bystander @556->560 -> 11 [COUNT] (from 11)
|
||||
R7 block @550 -> 11 [COUNT] (from 11)
|
||||
|
||||
@@ -0,0 +1,49 @@
|
||||
void func_8012E364(s32 arg0_)
|
||||
{
|
||||
|
||||
extern s16 D_80126CE0;
|
||||
extern s32 D_801ED9D8;
|
||||
extern s32 D_801ED9DC;
|
||||
s32 arg0;
|
||||
s32 prev;
|
||||
u16 flags;
|
||||
s32 a;
|
||||
s32 diff;
|
||||
s32 v;
|
||||
s32 d;
|
||||
s32 spd;
|
||||
s32 e1;
|
||||
s32 e2;
|
||||
|
||||
arg0 = arg0_;
|
||||
*(s16 *)(arg0 + 0x5C) = 0;
|
||||
a = D_80126CE0;
|
||||
if (a == 0) {
|
||||
D_801ED9D8 = 0x1000;
|
||||
D_801ED9DC = 0x1000;
|
||||
}
|
||||
a = ((0x90 - a) << 12) / 0x90;
|
||||
*(s32 *)(arg0 + 0x1C) += 1;
|
||||
spd = 0x1000;
|
||||
|
||||
diff = D_801ED9D8 - a;
|
||||
if (diff > 0) {
|
||||
D_801ED9D8 -= diff >> 2;
|
||||
} else if (diff < 0) {
|
||||
D_801ED9D8 += (-diff) / 4;
|
||||
}
|
||||
|
||||
prev = D_801ED9DC;
|
||||
e1 = *(s32 *)(arg0 + 0x20);
|
||||
v = spd + D_801ED9D8 - prev;
|
||||
D_801ED9DC = spd;
|
||||
flags = *(u16 *)(e1 + 0x2C);
|
||||
D_801ED9D8 = v;
|
||||
do { *(u16 *)(e1 + 0x2C) = flags | 0x10; } while (0);
|
||||
|
||||
e2 = *(s32 *)(arg0 + 0x20);
|
||||
d = __builtin_abs(v);
|
||||
*(s16 *)(e2 + 0x1C) = d;
|
||||
*(s16 *)(e2 + 0x18) = d;
|
||||
*(s16 *)(*(s32 *)(arg0 + 0x20) + 0x1A) = 0x1000;
|
||||
}
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 25 best 7 compiles 787 path R5 swap + @786 + R7 do-wh
|
||||
g5: verdict NO-MATCH start 25 best 7 compiles 2299 path R5 swap + @786 + R7 do-while @790
|
||||
s1: verdict NO-MATCH start 25 best 7 compiles 187 path R5 swap + @786 + R7 do-while @790
|
||||
s2: verdict NO-MATCH start 25 best 7 compiles 187 path R5 swap + @786 + R7 do-while @790
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 do-while @790 -> 7 (from 13)
|
||||
R7 do-while @790 -> 9 (from 13)
|
||||
R9 swap-stmts @793 -> 11 (from 13)
|
||||
R5 swap + @786 -> 13 (from 25)
|
||||
R13 assoc -+ @786 -> 13 (from 25)
|
||||
R2 decl-order 0,2,1 -> 13 (from 13)
|
||||
R4 decl-move prev 4->0 -> 13 (from 13)
|
||||
R7 block @789 -> 13 (from 13)
|
||||
R8 temp tmp0 @785 -> 13 (from 13)
|
||||
R10 param-alias arg0->arg0_ @766 -> 13 (from 13)
|
||||
R12 width e2 s32->u16 @764 -> 13 (from 13)
|
||||
R2 decl-order 1,0,2 -> 13 (from 13)
|
||||
s4: verdict NO-MATCH start 25 best 7 compiles 435 path R5 swap + @786 + R7 do-while @790
|
||||
s7: verdict NO-MATCH start 25 best 7 compiles 558 path R5 swap + @786 + R7 do-while @790
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 do-while @790 -> 7 [MIXED] (from 13)
|
||||
R2 decl-order 0,2,1 -> 7 [MIXED] (from 7)
|
||||
R4 decl-move prev 4->0 -> 7 [MIXED] (from 7)
|
||||
R7 block @792 -> 7 [MIXED] (from 7)
|
||||
R8 temp tmp0 @792 -> 7 [MIXED] (from 7)
|
||||
R10 param-alias arg0->arg0_ @766 -> 7 [MIXED] (from 7)
|
||||
R2 decl-order 1,0,2 -> 7 [MIXED] (from 7)
|
||||
R4 decl-move prev 4->1 -> 7 [MIXED] (from 7)
|
||||
R7 do-while @792 -> 7 [MIXED] (from 7)
|
||||
R8 base tmp0 @792 -> 7 [MIXED] (from 7)
|
||||
R10 param-copy arg0_ @765 -> 7 [MIXED] (from 7)
|
||||
R18 bystander @774->777 -> 7 [MIXED] (from 7)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 18 best 18 compiles 815 path
|
||||
g5: verdict NO-MATCH start 18 best 18 compiles 2342 path
|
||||
s1: verdict NO-MATCH start 18 best 18 compiles 190 path
|
||||
s2: verdict NO-MATCH start 18 best 18 compiles 190 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R8 temp tmp0 @1162 -> 18 (from 18)
|
||||
R7 block @1164 -> 18 (from 18)
|
||||
R8 base tmp0 @1162 -> 18 (from 18)
|
||||
R7 do-while @1164 -> 18 (from 18)
|
||||
R9 swap-stmts @1161 -> 18 (from 18)
|
||||
R8 hoist tmp0 @1221 -> 18 (from 18)
|
||||
R7 block @1262 -> 18 (from 18)
|
||||
R8 temp tmp0 @1161 -> 18 (from 18)
|
||||
R7 do-while @1262 -> 18 (from 18)
|
||||
R9 swap-stmts @1225 -> 18 (from 18)
|
||||
R8 base tmp0 @1161 -> 18 (from 18)
|
||||
R7 block @1200 -> 18 (from 18)
|
||||
s4: verdict NO-MATCH start 18 best 18 compiles 443 path
|
||||
s7: verdict NO-MATCH start 18 best 18 compiles 566 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R8 temp tmp0 @1162 -> 18 [COUNT] (from 18)
|
||||
R7 block @1164 -> 18 [COUNT] (from 18)
|
||||
R8 base tmp0 @1162 -> 18 [COUNT] (from 18)
|
||||
R7 do-while @1164 -> 18 [COUNT] (from 18)
|
||||
R9 swap-stmts @1161 -> 18 [COUNT] (from 18)
|
||||
R8 hoist tmp0 @1221 -> 18 [COUNT] (from 18)
|
||||
R7 block @1262 -> 18 [COUNT] (from 18)
|
||||
R8 temp tmp0 @1161 -> 18 [COUNT] (from 18)
|
||||
R7 do-while @1262 -> 18 [COUNT] (from 18)
|
||||
R9 swap-stmts @1225 -> 18 [COUNT] (from 18)
|
||||
R8 base tmp0 @1161 -> 18 [COUNT] (from 18)
|
||||
R7 block @1200 -> 18 [COUNT] (from 18)
|
||||
|
||||
@@ -4,16 +4,18 @@ s1: verdict NO-MATCH start 21 best 21 compiles 186 path
|
||||
s2: verdict NO-MATCH start 21 best 21 compiles 187 path
|
||||
s3: verdict BUDGET start 21 best 21 compiles 400 path
|
||||
s3b: verdict BUDGET start 21 best 21 compiles 400 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 block @2230 -> 21 (from 21)
|
||||
R10 param-copy arg0 @2201 -> 21 (from 21)
|
||||
R4 decl-move s3 6->0 -> 21 (from 21)
|
||||
R12 width arg0s s16->u16 @2198 -> 21 (from 21)
|
||||
R6 inline ret0 @2248 -> 21 (from 21)
|
||||
R7 do-while @2230 -> 21 (from 21)
|
||||
R2 decl-order 0,2,1,3 -> 21 (from 21)
|
||||
R4 decl-move s3 6->1 -> 21 (from 21)
|
||||
R7 block @2212 -> 21 (from 21)
|
||||
R10 param-copy arg2 @2201 -> 21 (from 21)
|
||||
R4 decl-move s3 6->2 -> 21 (from 21)
|
||||
R9 swap-stmts @2238 -> 21 (from 21)
|
||||
s4: verdict NO-MATCH start 21 best 21 compiles 435 path
|
||||
s7: verdict NO-MATCH start 21 best 21 compiles 547 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R18 bystander @2202->2205 -> 21 [COUNT] (from 21)
|
||||
R7 block @2230 -> 21 [COUNT] (from 21)
|
||||
R10 param-copy arg0 @2201 -> 21 [COUNT] (from 21)
|
||||
R4 decl-move s3 6->0 -> 21 [COUNT] (from 21)
|
||||
R12 width arg0s s16->u16 @2198 -> 21 [COUNT] (from 21)
|
||||
R6 inline ret0 @2248 -> 21 [COUNT] (from 21)
|
||||
R18 bystander @2202->2206 -> 21 [COUNT] (from 21)
|
||||
R7 do-while @2230 -> 21 [COUNT] (from 21)
|
||||
R2 decl-order 0,2,1,3 -> 21 [COUNT] (from 21)
|
||||
R4 decl-move s3 6->1 -> 21 [COUNT] (from 21)
|
||||
R7 block @2212 -> 21 [COUNT] (from 21)
|
||||
R10 param-copy arg2 @2201 -> 21 [COUNT] (from 21)
|
||||
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 24 best 23 compiles 810 path R8 hoist tmp0 @2331 + R9
|
||||
g5: verdict NO-MATCH start 24 best 17 compiles 2247 path R12 width harg int->u16 @2317 + R12 width cnt int->u16 @2312
|
||||
s1: verdict NO-MATCH start 24 best 20 compiles 185 path R12 width harg int->u16 @2317
|
||||
s2: verdict NO-MATCH start 24 best 20 compiles 185 path R12 width harg int->u16 @2317
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R12 width harg int->u16 @2317 -> 20 (from 24)
|
||||
R12 width harg int->s16 @2317 -> 20 (from 24)
|
||||
R8 hoist tmp0 @2325 -> 20 (from 20)
|
||||
R7 block @2325 -> 20 (from 20)
|
||||
R4 decl-move harg 13->0 -> 20 (from 20)
|
||||
R12 width ret s32->s16 @2318 -> 20 (from 20)
|
||||
R14 param-width flag s16->u16 @2297 -> 20 (from 20)
|
||||
R10 param-copy x @2322 -> 20 (from 20)
|
||||
R4 decl-move harg 13->1 -> 20 (from 20)
|
||||
R6 inline off @2345 -> 20 (from 20)
|
||||
R7 block @2324 -> 20 (from 20)
|
||||
R10 param-copy y @2322 -> 20 (from 20)
|
||||
s4: verdict NO-MATCH start 24 best 20 compiles 435 path R12 width harg int->u16 @2317
|
||||
s7: verdict NO-MATCH start 24 best 20 compiles 548 path R12 width harg int->u16 @2317
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R12 width harg int->u16 @2317 -> 20 [COUNT] (from 24)
|
||||
R12 width harg int->s16 @2317 -> 20 [COUNT] (from 24)
|
||||
R8 hoist tmp0 @2325 -> 20 [COUNT] (from 20)
|
||||
R18 bystander @2325->2327 -> 20 [COUNT] (from 20)
|
||||
R7 block @2325 -> 20 [COUNT] (from 20)
|
||||
R4 decl-move harg 13->0 -> 20 [COUNT] (from 20)
|
||||
R12 width ret s32->s16 @2318 -> 20 [COUNT] (from 20)
|
||||
R10 param-copy x @2322 -> 20 [COUNT] (from 20)
|
||||
R4 decl-move harg 13->1 -> 20 [COUNT] (from 20)
|
||||
R6 inline off @2345 -> 20 [COUNT] (from 20)
|
||||
R7 block @2324 -> 20 [COUNT] (from 20)
|
||||
R10 param-copy y @2322 -> 20 [COUNT] (from 20)
|
||||
|
||||
@@ -0,0 +1,161 @@
|
||||
s32 func_80133CD4(arg0, cmd, base, arr)
|
||||
s16 arg0;
|
||||
s16 *cmd;
|
||||
s16 *base;
|
||||
s32 *arr;
|
||||
{
|
||||
|
||||
extern u16 *D_801909C0;
|
||||
extern u16 *D_801909BC;
|
||||
extern s16 *D_801909C8;
|
||||
extern s16 *D_801909C4;
|
||||
extern s32 *D_801909D0;
|
||||
extern s32 *D_801909D4;
|
||||
extern u16 D_801EDA40;
|
||||
extern u8 D_801152A8[];
|
||||
extern s16 D_801152AA;
|
||||
extern s16 D_801152AC;
|
||||
extern u16 D_801152AE;
|
||||
extern u8 D_801152B0;
|
||||
extern s32 func_80134310();
|
||||
extern s32 func_8013435C();
|
||||
|
||||
s16 *s3 = ((ElemK *)base)[cmd[1]].e;
|
||||
s32 s6 = arr[cmd[2]];
|
||||
s32 s0var, s1var;
|
||||
s32 s2a;
|
||||
s16 y;
|
||||
|
||||
if (func_80134310(s3, D_801909C0, s6) >= 0)
|
||||
return 0;
|
||||
|
||||
s1var = func_80134310(s3, D_801909BC, s6);
|
||||
if (s1var < 0)
|
||||
return 0;
|
||||
|
||||
s0var = func_80134310(s3, D_801909C8, 0);
|
||||
{
|
||||
u16 *pac = D_801909BC;
|
||||
s16 *pb8 = D_801909C8;
|
||||
s16 *pb4 = D_801909C4;
|
||||
s32 neg = -s1var;
|
||||
pb4[0] = pac[0] + neg * pb8[0] / s0var;
|
||||
pb4[1] = pac[1] + neg * pb8[1] / s0var;
|
||||
pb4[2] = pac[2] + neg * pb8[2] / s0var;
|
||||
if (func_8013435C(((ElemK *)base)[cmd[3]].e, pb4, arr[cmd[4]], s3))
|
||||
return 0;
|
||||
}
|
||||
if (func_8013435C(((ElemK *)base)[cmd[5]].e, D_801909C4, arr[cmd[6]], s3))
|
||||
return 0;
|
||||
if (func_8013435C(((ElemK *)base)[cmd[7]].e, D_801909C4, arr[cmd[8]], s3))
|
||||
return 0;
|
||||
if (arg0 < 0) {
|
||||
if (func_8013435C(((ElemK *)base)[cmd[9]].e, D_801909C4, arr[cmd[10]], s3))
|
||||
return 0;
|
||||
}
|
||||
if (arg0 & 0x10) {
|
||||
if (*(u16 *)cmd & 0x100)
|
||||
return 0;
|
||||
}
|
||||
if (*(u16 *)cmd & 0x200) {
|
||||
D_801EDA40 = *(u16 *)cmd;
|
||||
return 0;
|
||||
}
|
||||
|
||||
{
|
||||
s32 ret = func_80134310(s3, D_801909C0, s6);
|
||||
s32 *pc0;
|
||||
s32 *pc4;
|
||||
u16 *pb0;
|
||||
s32 t, o2;
|
||||
s32 q3v;
|
||||
|
||||
{
|
||||
s32 *pw = D_801909D0;
|
||||
((struct { s32 w; } *)pw)->w = s3[0];
|
||||
pw[1] = s3[1];
|
||||
pw[2] = s3[2];
|
||||
}
|
||||
s1var = -ret;
|
||||
|
||||
__asm__ __volatile__(
|
||||
"lwc2 $9, 0(%0)\n"
|
||||
"lwc2 $10, 4(%0)\n"
|
||||
"lwc2 $11, 8(%0)\n"
|
||||
"nop\n"
|
||||
"nop\n"
|
||||
"sqr 0\n"
|
||||
: : "r"(D_801909D0) : "$9", "$10", "$11", "memory");
|
||||
gte_stlvnl(D_801909D4);
|
||||
|
||||
pc0 = D_801909D0;
|
||||
pc4 = D_801909D4;
|
||||
s0var = pc4[0] + pc4[1] + pc4[2];
|
||||
pb0 = D_801909C0;
|
||||
pb0[0] += s1var * pc0[0] / s0var;
|
||||
pb0[1] += s1var * pc0[1] / s0var;
|
||||
q3v = s1var * pc0[2] / s0var;
|
||||
|
||||
{
|
||||
s32 h;
|
||||
h = ((s16 *)pb0)[0];
|
||||
s1var = h << 16;
|
||||
h = *(s16 *)((s32)pb0 + 2);
|
||||
s0var = h << 16;
|
||||
}
|
||||
pb0[2] += q3v;
|
||||
s2a = (s16)pb0[2] << 16;
|
||||
|
||||
t = pc0[0] << 4;
|
||||
pc0[0] = t;
|
||||
if (t < 0) s1var |= 0xFFFF;
|
||||
t = pc0[1] << 4;
|
||||
pc0[1] = t;
|
||||
if (t < 0) s0var |= 0xFFFF;
|
||||
o2 = pc0[2];
|
||||
t = o2 << 4;
|
||||
pc0[2] = t;
|
||||
if (t < 0) s2a |= 0xFFFF;
|
||||
s2a += o2 << 5;
|
||||
s1var += pc0[0] << 1;
|
||||
s0var += pc0[1] << 1;
|
||||
|
||||
do {
|
||||
s32 *pl = D_801909D0;
|
||||
u16 *pb;
|
||||
s1var += pl[0];
|
||||
s0var += pl[1];
|
||||
s2a += pl[2];
|
||||
pb = D_801909C0;
|
||||
pb[0] = s1var >> 16;
|
||||
pb[1] = s0var >> 16;
|
||||
pb[2] = s2a >> 16;
|
||||
ret = func_80134310(s3, pb, s6);
|
||||
} while (ret < ((s3[1] < -0xE00) ? 0x1800 : 0x2F00));
|
||||
}
|
||||
|
||||
y = s3[1];
|
||||
if (y >= -0xBCB) {
|
||||
D_801909BC[3] = y;
|
||||
{
|
||||
typedef struct { s8 c[8]; } Blk8;
|
||||
*(Blk8 *)&D_801152B0 = *(Blk8 *)s3;
|
||||
}
|
||||
if (*(u8 *)cmd != 0)
|
||||
goto ret1;
|
||||
return -1;
|
||||
}
|
||||
{
|
||||
u16 *s3u = (u16 *)s3;
|
||||
u16 *bp = D_801909C0;
|
||||
u16 w;
|
||||
((H16 *)D_801152A8)->h = s3u[0];
|
||||
w = s3u[1];
|
||||
bp[3] = w;
|
||||
((H16 *)&D_801152AA)->h = w;
|
||||
((H16 *)&D_801152AC)->h = s3u[2];
|
||||
((H16 *)&D_801152AE)->h = s3u[3];
|
||||
}
|
||||
ret1:
|
||||
return 1;
|
||||
}
|
||||
@@ -2,16 +2,18 @@ g2: verdict NO-MATCH start 28 best 10 compiles 808 path R7 do-while @2471 + R6 i
|
||||
g5: verdict NO-MATCH start 28 best 8 compiles 2339 path R7 do-while @2479 + R7 do-while @2478 + R8 hoist tmp0 @2482 + R9 swap-stmts @2482
|
||||
s1: verdict NO-MATCH start 28 best 16 compiles 189 path R7 do-while @2471 + R7 do-while @2481
|
||||
s2: verdict NO-MATCH start 28 best 16 compiles 189 path R7 do-while @2471 + R7 do-while @2481
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 do-while @2481 -> 16 (from 26)
|
||||
R6 inline h @2476 -> 17 (from 26)
|
||||
R7 do-while @2481 -> 18 (from 28)
|
||||
R8 hoist tmp0 @2472 -> 18 (from 18)
|
||||
R7 block @2491 -> 18 (from 18)
|
||||
R6 inline h @2476 -> 18 (from 18)
|
||||
R7 do-while @2491 -> 18 (from 18)
|
||||
R8 hoist tmp0 @2482 -> 18 (from 18)
|
||||
R7 block @2492 -> 18 (from 18)
|
||||
R8 hoist tmp0 @2487 -> 18 (from 18)
|
||||
R7 do-while @2492 -> 18 (from 18)
|
||||
R8 temp tmp0 @2478 -> 18 (from 18)
|
||||
s4: verdict NO-MATCH start 28 best 10 compiles 443 path R7 do-while @2471 + R6 inline h @2476 + R7 do-while @2483
|
||||
s7: verdict NO-MATCH start 28 best 10 compiles 567 path R7 do-while @2471 + R6 inline h @2476 + R7 do-while @2483
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 do-while @2483 -> 10 [COUNT] (from 17)
|
||||
R7 do-while @2481 -> 11 [COUNT] (from 17)
|
||||
R7 do-while @2481 -> 16 [MIXED] (from 26)
|
||||
R8 hoist tmp0 @2472 -> 16 [MIXED] (from 16)
|
||||
R7 block @2491 -> 16 [MIXED] (from 16)
|
||||
R18 bystander @2464->2466 -> 16 [MIXED] (from 16)
|
||||
R7 do-while @2491 -> 16 [MIXED] (from 16)
|
||||
R8 hoist tmp0 @2487 -> 16 [MIXED] (from 16)
|
||||
R7 block @2492 -> 16 [MIXED] (from 16)
|
||||
R8 hoist tmp0 @2482 -> 16 [MIXED] (from 16)
|
||||
R18 bystander @2466->2469 -> 16 [MIXED] (from 16)
|
||||
R7 do-while @2492 -> 16 [MIXED] (from 16)
|
||||
|
||||
@@ -0,0 +1,51 @@
|
||||
s32 func_801345F8(s32 arg)
|
||||
{
|
||||
extern int func_801347A0(short, u16 *, int, int);
|
||||
extern u16 * D_801909BC;
|
||||
extern u16 D_801EDA40;
|
||||
|
||||
u16 *cc = D_801909BC;
|
||||
u16 *param_1 = ((u16 *)arg);
|
||||
int c8000 = 0x8000;
|
||||
u32 c1, c2, uVar2, cnt, v14;
|
||||
u16 uVar6;
|
||||
u16 *ptmp, *puVar4, *puVar7, uVar1;
|
||||
u16 harg;
|
||||
int hi, iVar9, iVar8, uVar3, uVar10, tbl;
|
||||
|
||||
c1 = ((int)(cc[0] + c8000) >> 7 & 0x1ff) - (u32)param_1[0];
|
||||
uVar6 = c1 + 0;
|
||||
if ((c1 & 0xffff) < (u32)param_1[2]) {
|
||||
c2 = ((int)(cc[2] + c8000) >> 7 & 0x1ff) - (u32)param_1[1];
|
||||
uVar2 = c2 + 0;
|
||||
if ((c2 & 0xffff) < (u32)param_1[3])
|
||||
goto do_mult;
|
||||
return 0;
|
||||
found:
|
||||
D_801EDA40 = *puVar7;
|
||||
return 1;
|
||||
do_mult:
|
||||
tbl = *(int *)(param_1 + 4);
|
||||
uVar10 = *(int *)(param_1 + 6);
|
||||
uVar3 = *(int *)(param_1 + 8);
|
||||
iVar9 = *(int *)(param_1 + 0xc);
|
||||
iVar8 = *(int *)(param_1 + 0xe);
|
||||
ptmp = (u16 *)((((u32)(u16)uVar2 * (u32)param_1[2] + (u32)(u16)uVar6) * 2 & 0xffff) * 2 + tbl);
|
||||
cnt = (u32)ptmp[1];
|
||||
v14 = *(int *)(param_1 + 10);
|
||||
puVar4 = (u16 *)(v14 + (u32)*ptmp + cnt * 2) - 1;
|
||||
while (((cnt-- + 0) & 0xffff) != 0) {
|
||||
uVar1 = *puVar4;
|
||||
hi = uVar1 & 0x8000;
|
||||
harg = hi + 0;
|
||||
if (hi == 0)
|
||||
puVar7 = (u16 *)(iVar9 + (u32)uVar1 * 0x12);
|
||||
else
|
||||
puVar7 = (u16 *)(iVar8 + (uVar1 & 0x7fff) * 0x16);
|
||||
if (func_801347A0((short)harg, puVar7, uVar3, uVar10) != 0)
|
||||
goto found;
|
||||
puVar4 = puVar4 - 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 39 best 14 compiles 769 path R2 decl-order 1,0 + R9 s
|
||||
g5: verdict NO-MATCH start 39 best 7 compiles 2286 path R2 decl-order 1,0 + R12 width uVar6 u32->u16 @2665 + R12 width harg int->u16 @2668
|
||||
s1: verdict NO-MATCH start 39 best 13 compiles 180 path R3 init-split param_1 + R12 width harg int->u16 @2667
|
||||
s2: verdict NO-MATCH start 39 best 13 compiles 180 path R3 init-split param_1 + R12 width harg int->u16 @2667
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R12 width harg int->u16 @2667 -> 13 (from 19)
|
||||
R12 width harg int->s16 @2667 -> 13 (from 19)
|
||||
R12 width uVar6 u32->u16 @2665 -> 13 (from 19)
|
||||
R12 width uVar6 u32->s16 @2665 -> 13 (from 19)
|
||||
R12 width uVar6 u32->u16 @2665 -> 13 (from 19)
|
||||
R12 width harg int->u8 @2667 -> 17 (from 19)
|
||||
R9 swap-stmts @2670 -> 18 (from 19)
|
||||
R12 width c1 u32->s16 @2665 -> 18 (from 19)
|
||||
R9 swap-stmts @2669 -> 18 (from 19)
|
||||
R12 width c1 u32->s16 @2665 -> 18 (from 19)
|
||||
R9 swap-stmts @2669 -> 18 (from 19)
|
||||
R3 init-split param_1 -> 19 (from 39)
|
||||
s4: verdict NO-MATCH start 39 best 7 compiles 431 path R2 decl-order 1,0 + R12 width uVar6 u32->u16 @2665 + R12 width harg int->u16 @2668
|
||||
s7: verdict NO-MATCH start 39 best 7 compiles 545 path R2 decl-order 1,0 + R12 width uVar6 u32->u16 @2665 + R12 width harg int->u16 @2668
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R12 width harg int->u16 @2668 -> 7 [COUNT] (from 13)
|
||||
R12 width harg int->s16 @2668 -> 7 [COUNT] (from 13)
|
||||
R12 width harg int->u16 @2668 -> 7 [COUNT] (from 13)
|
||||
R12 width harg int->s16 @2668 -> 7 [COUNT] (from 13)
|
||||
R12 width harg int->u8 @2668 -> 11 [COUNT] (from 13)
|
||||
R12 width harg int->u8 @2668 -> 11 [COUNT] (from 13)
|
||||
R9 swap-stmts @2671 -> 12 [COUNT] (from 13)
|
||||
R18 bystander @2672->2669 -> 12 [COUNT] (from 13)
|
||||
R9 swap-stmts @2671 -> 12 [COUNT] (from 13)
|
||||
R18 bystander @2672->2669 -> 12 [COUNT] (from 13)
|
||||
R12 width harg int->u16 @2667 -> 13 [COUNT] (from 19)
|
||||
R12 width harg int->s16 @2667 -> 13 [COUNT] (from 19)
|
||||
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 30 best 24 compiles 805 path R9 swap-stmts @2808 + R9
|
||||
g5: verdict NO-MATCH start 30 best 17 compiles 2314 path R9 swap-stmts @2808 + R12 width hic u32->u16 @2787 + R9 swap-stmts @2794 + R9 swap-stmts @2791
|
||||
s1: verdict NO-MATCH start 30 best 26 compiles 190 path R9 swap-stmts @2808
|
||||
s2: verdict NO-MATCH start 30 best 26 compiles 190 path R9 swap-stmts @2808
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R9 swap-stmts @2808 -> 26 (from 30)
|
||||
R8 hoist tmp0 @2808 -> 26 (from 26)
|
||||
R7 block @2808 -> 26 (from 26)
|
||||
R10 param-copy param_1 @2789 -> 26 (from 26)
|
||||
R2 decl-order 1,0 -> 26 (from 26)
|
||||
R4 decl-move n 3->0 -> 26 (from 26)
|
||||
R8 temp tmp0 @2806 -> 26 (from 26)
|
||||
R10 param-copy param_2 @2789 -> 26 (from 26)
|
||||
R4 decl-move n 3->1 -> 26 (from 26)
|
||||
R6 inline uVar6c @2791 -> 26 (from 26)
|
||||
R8 base tmp0 @2806 -> 26 (from 26)
|
||||
R7 block @2806 -> 26 (from 26)
|
||||
s4: verdict NO-MATCH start 30 best 25 compiles 438 path R9 swap-stmts @2808 + R9 swap-stmts @2793
|
||||
s7: verdict NO-MATCH start 30 best 22 compiles 562 path R6 inline p0 @2807 + R12 width hic u32->u16 @2786 + R9 swap-stmts @2807
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R9 swap-stmts @2807 -> 22 [COUNT] (from 26)
|
||||
R9 swap-stmts @2807 -> 22 [COUNT] (from 26)
|
||||
R9 swap-stmts @2793 -> 25 [COUNT] (from 26)
|
||||
R8 temp tmp0 @2803 -> 25 [COUNT] (from 25)
|
||||
R7 block @2803 -> 25 [COUNT] (from 25)
|
||||
R10 param-copy param_1 @2789 -> 25 [COUNT] (from 25)
|
||||
R2 decl-order 1,0 -> 25 [COUNT] (from 25)
|
||||
R4 decl-move n 3->0 -> 25 [COUNT] (from 25)
|
||||
R8 base tmp0 @2803 -> 25 [COUNT] (from 25)
|
||||
R10 param-copy param_2 @2789 -> 25 [COUNT] (from 25)
|
||||
R4 decl-move n 3->1 -> 25 [COUNT] (from 25)
|
||||
R8 temp tmp0 @2806 -> 25 [COUNT] (from 25)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 26 best 23 compiles 677 path R7 do-while @2953
|
||||
g5: verdict NO-MATCH start 26 best 23 compiles 2234 path R7 do-while @2950
|
||||
s1: verdict NO-MATCH start 26 best 23 compiles 186 path R7 do-while @2950
|
||||
s2: verdict NO-MATCH start 26 best 23 compiles 186 path R7 do-while @2950
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 do-while @2950 -> 23 (from 26)
|
||||
R10 param-copy arg0 @2947 -> 23 (from 23)
|
||||
R12 width a u16->s32 @2944 -> 23 (from 23)
|
||||
R14 param-width arg0 s32->s16 @2931 -> 23 (from 23)
|
||||
R2 decl-order 0,2,1 -> 23 (from 23)
|
||||
R4 decl-move pb0 5->0 -> 23 (from 23)
|
||||
R10 param-copy p1 @2947 -> 23 (from 23)
|
||||
R12 width a u16->s16 @2944 -> 23 (from 23)
|
||||
R14 param-width arg0 s32->u16 @2931 -> 23 (from 23)
|
||||
R7 block @2951 -> 23 (from 23)
|
||||
R9 swap-stmts @2954 -> 23 (from 23)
|
||||
R2 decl-order 1,0,2 -> 23 (from 23)
|
||||
s4: verdict NO-MATCH start 26 best 23 compiles 435 path R7 do-while @2950
|
||||
s7: verdict NO-MATCH start 26 best 23 compiles 553 path R7 do-while @2950
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 do-while @2950 -> 23 [REG] (from 26)
|
||||
R18 bystander @2952->2954 -> 23 [REG] (from 23)
|
||||
R10 param-copy arg0 @2947 -> 23 [REG] (from 23)
|
||||
R12 width a u16->s32 @2944 -> 23 [REG] (from 23)
|
||||
R14 param-width arg0 s32->s16 @2931 -> 23 [REG] (from 23)
|
||||
R2 decl-order 0,2,1 -> 23 [REG] (from 23)
|
||||
R4 decl-move pb0 5->0 -> 23 [REG] (from 23)
|
||||
R10 param-copy p1 @2947 -> 23 [REG] (from 23)
|
||||
R12 width a u16->s16 @2944 -> 23 [REG] (from 23)
|
||||
R14 param-width arg0 s32->u16 @2931 -> 23 [REG] (from 23)
|
||||
R7 block @2951 -> 23 [REG] (from 23)
|
||||
R9 swap-stmts @2954 -> 23 [REG] (from 23)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 25 best 16 compiles 524 path R7 do-while @3022 + R7 d
|
||||
g5: verdict NO-MATCH start 25 best 16 compiles 859 path R7 do-while @3019 + R7 do-while @3012
|
||||
s1: verdict NO-MATCH start 25 best 16 compiles 167 path R7 do-while @3019 + R7 do-while @3012
|
||||
s2: verdict NO-MATCH start 25 best 16 compiles 167 path R7 do-while @3019 + R7 do-while @3012
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 do-while @3012 -> 16 (from 20)
|
||||
R7 do-while @3019 -> 20 (from 25)
|
||||
R7 block @3012 -> 20 (from 20)
|
||||
R2 decl-order 0,2,1 -> 20 (from 20)
|
||||
R2 decl-order 1,0,2 -> 20 (from 20)
|
||||
R7 block @3014 -> 20 (from 20)
|
||||
R2 decl-order 1,2,0 -> 20 (from 20)
|
||||
R2 decl-order 2,0,1 -> 20 (from 20)
|
||||
R7 block @3015 -> 20 (from 20)
|
||||
R2 decl-order 2,1,0 -> 20 (from 20)
|
||||
R7 do-while @3015 -> 20 (from 20)
|
||||
R7 block @3016 -> 20 (from 20)
|
||||
s4: verdict NO-MATCH start 25 best 16 compiles 419 path R18 bystander @3012->3018
|
||||
s7: verdict NO-MATCH start 25 best 16 compiles 532 path R18 bystander @3012->3018
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R18 bystander @3012->3018 -> 16 [COUNT] (from 25)
|
||||
R7 block @3013 -> 16 [COUNT] (from 16)
|
||||
R2 decl-order 0,2,1 -> 16 [COUNT] (from 16)
|
||||
R2 decl-order 1,0,2 -> 16 [COUNT] (from 16)
|
||||
R7 block @3014 -> 16 [COUNT] (from 16)
|
||||
R9 swap-stmts @3017 -> 16 [COUNT] (from 16)
|
||||
R2 decl-order 1,2,0 -> 16 [COUNT] (from 16)
|
||||
R7 do-while @3014 -> 16 [COUNT] (from 16)
|
||||
R2 decl-order 2,0,1 -> 16 [COUNT] (from 16)
|
||||
R7 block @3015 -> 16 [COUNT] (from 16)
|
||||
R2 decl-order 2,1,0 -> 16 [COUNT] (from 16)
|
||||
R7 block @3017 -> 16 [COUNT] (from 16)
|
||||
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 29 best 16 compiles 822 path R10 param-alias p1->arg1
|
||||
g5: verdict NO-MATCH start 29 best 16 compiles 2278 path R10 param-alias p1->arg1 @647 + R6 inline m @654
|
||||
s1: verdict NO-MATCH start 29 best 16 compiles 190 path R10 param-alias p1->arg1 @647 + R6 inline m @654
|
||||
s2: verdict NO-MATCH start 29 best 16 compiles 190 path R10 param-alias p1->arg1 @647 + R6 inline m @654
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R6 inline m @654 -> 16 (from 20)
|
||||
R6 inline m @660 -> 16 (from 20)
|
||||
R10 param-alias p1->arg1 @647 -> 20 (from 29)
|
||||
R7 block @665 -> 20 (from 20)
|
||||
R10 param-alias p3->arg3 @647 -> 20 (from 20)
|
||||
R2 decl-order 0,1,3,2 -> 20 (from 20)
|
||||
R4 decl-move m 1->0 -> 20 (from 20)
|
||||
R2 decl-order 0,2,1,3 -> 20 (from 20)
|
||||
R4 decl-move m 1->2 -> 20 (from 20)
|
||||
R7 block @659 -> 20 (from 20)
|
||||
R10 param-copy arg0 @645 -> 20 (from 20)
|
||||
R2 decl-order 0,2,3,1 -> 20 (from 20)
|
||||
s4: verdict NO-MATCH start 29 best 16 compiles 444 path R10 param-alias p1->arg1 @647 + R6 inline m @654
|
||||
s7: verdict NO-MATCH start 29 best 16 compiles 569 path R10 param-alias p1->arg1 @647 + R6 inline m @654
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R6 inline m @654 -> 16 [COUNT] (from 20)
|
||||
R6 inline m @660 -> 16 [COUNT] (from 20)
|
||||
R7 block @669 -> 16 [COUNT] (from 16)
|
||||
R10 param-alias p3->arg3 @647 -> 16 [COUNT] (from 16)
|
||||
R2 decl-order 0,1,3,2 -> 16 [COUNT] (from 16)
|
||||
R4 decl-move m 1->0 -> 16 [COUNT] (from 16)
|
||||
R2 decl-order 0,2,1,3 -> 16 [COUNT] (from 16)
|
||||
R4 decl-move m 1->2 -> 16 [COUNT] (from 16)
|
||||
R8 hoist tmp0 @654 -> 16 [COUNT] (from 16)
|
||||
R7 block @670 -> 16 [COUNT] (from 16)
|
||||
R10 param-copy arg0 @645 -> 16 [COUNT] (from 16)
|
||||
R2 decl-order 0,2,3,1 -> 16 [COUNT] (from 16)
|
||||
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 40 best 24 compiles 812 path R8 cse tmp0 @654 + R8 cs
|
||||
g5: verdict NO-MATCH start 40 best 24 compiles 2267 path R8 cse tmp0 @654 + R8 cse tmp1 @680
|
||||
s1: verdict NO-MATCH start 40 best 24 compiles 188 path R8 cse tmp0 @678 + R8 cse tmp1 @655
|
||||
s2: verdict NO-MATCH start 40 best 32 compiles 188 path R8 cse tmp0 @678 + R10 param-copy a2 @649
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R10 param-copy a2 @649 -> 32 (from 33)
|
||||
R8 cse tmp0 @678 -> 33 (from 40)
|
||||
R12 width i s16->s32 @644 -> 33 (from 33)
|
||||
R7 block @660 -> 33 (from 33)
|
||||
R4 decl-move s7 10->0 -> 33 (from 33)
|
||||
R12 width i s16->u16 @644 -> 33 (from 33)
|
||||
R7 do-while @660 -> 33 (from 33)
|
||||
R9 swap-stmts @666 -> 33 (from 33)
|
||||
R4 decl-move s7 10->1 -> 33 (from 33)
|
||||
R7 block @666 -> 33 (from 33)
|
||||
R4 decl-move s7 10->2 -> 33 (from 33)
|
||||
R7 do-while @666 -> 33 (from 33)
|
||||
s4: verdict NO-MATCH start 40 best 24 compiles 444 path R8 cse tmp0 @678 + R8 cse tmp1 @655
|
||||
s7: verdict NO-MATCH start 40 best 24 compiles 570 path R8 cse tmp0 @678 + R8 cse tmp1 @655
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R8 cse tmp1 @655 -> 24 [COUNT] (from 33)
|
||||
R12 width i s16->s32 @644 -> 24 [COUNT] (from 24)
|
||||
R7 block @667 -> 24 [COUNT] (from 24)
|
||||
R4 decl-move s7 10->0 -> 24 [COUNT] (from 24)
|
||||
R12 width i s16->u16 @644 -> 24 [COUNT] (from 24)
|
||||
R4 decl-move s7 10->1 -> 24 [COUNT] (from 24)
|
||||
R7 block @664 -> 24 [COUNT] (from 24)
|
||||
R9 swap-stmts @668 -> 24 [COUNT] (from 24)
|
||||
R4 decl-move s7 10->2 -> 24 [COUNT] (from 24)
|
||||
R7 do-while @664 -> 24 [COUNT] (from 24)
|
||||
R10 param-copy a3 @650 -> 24 [COUNT] (from 24)
|
||||
R4 decl-move s7 10->3 -> 24 [COUNT] (from 24)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 64 best 57 compiles 815 path R8 hoist tmp0 @805 + R9
|
||||
g5: verdict NO-MATCH start 64 best 52 compiles 2295 path R9 swap-stmts @824 + R7 do-while @827 + R6 inline w @898
|
||||
s1: verdict NO-MATCH start 64 best 63 compiles 188 path R9 swap-stmts @818
|
||||
s2: verdict NO-MATCH start 64 best 63 compiles 188 path R9 swap-stmts @818
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R9 swap-stmts @818 -> 63 (from 64)
|
||||
R3 init-split arg1 -> 63 (from 63)
|
||||
R7 block @797 -> 63 (from 63)
|
||||
R9 swap-stmts @817 -> 63 (from 63)
|
||||
R10 param-copy arg0 @788 -> 63 (from 63)
|
||||
R2 decl-order 1,0 -> 63 (from 63)
|
||||
R4 decl-move arg1 5->0 -> 63 (from 63)
|
||||
R12 width t2 s32->s16 @775 -> 63 (from 63)
|
||||
R14 param-width arg1_ s32->u16 @767 -> 63 (from 63)
|
||||
R8 hoist tmp0 @805 -> 63 (from 63)
|
||||
R7 do-while @797 -> 63 (from 63)
|
||||
R4 decl-move arg1 5->1 -> 63 (from 63)
|
||||
s4: verdict NO-MATCH start 64 best 53 compiles 426 path R18 bystander @818->821 + R7 do-while @817 + R18 bystander @823->818
|
||||
s7: verdict NO-MATCH start 64 best 53 compiles 553 path R18 bystander @818->821 + R7 do-while @817 + R18 bystander @823->818
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R18 bystander @823->818 -> 53 [COUNT] (from 55)
|
||||
R18 bystander @823->819 -> 54 [COUNT] (from 55)
|
||||
R7 do-while @817 -> 55 [COUNT] (from 63)
|
||||
R3 init-split arg1 -> 55 [COUNT] (from 55)
|
||||
R7 block @797 -> 55 [COUNT] (from 55)
|
||||
R10 param-copy arg0 @788 -> 55 [COUNT] (from 55)
|
||||
R2 decl-order 1,0 -> 55 [COUNT] (from 55)
|
||||
R4 decl-move arg1 5->0 -> 55 [COUNT] (from 55)
|
||||
R12 width t2 s32->s16 @775 -> 55 [COUNT] (from 55)
|
||||
R8 hoist tmp0 @851 -> 55 [COUNT] (from 55)
|
||||
R7 do-while @797 -> 55 [COUNT] (from 55)
|
||||
R9 swap-stmts @827 -> 55 [COUNT] (from 55)
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
s32 func_80136334(void *arg0, s32 arg1, s32 arg2) {
|
||||
extern u8 D_801152A8[];
|
||||
extern s16 D_801152AA;
|
||||
extern s16 D_801152AC;
|
||||
extern s16 D_80126722;
|
||||
extern s16 D_80126724;
|
||||
s32 a1v;
|
||||
s32 a2v;
|
||||
s32 n;
|
||||
s16 *b4;
|
||||
s32 d;
|
||||
s32 dx;
|
||||
s32 denom;
|
||||
s32 result;
|
||||
s32 frame_pad[2];
|
||||
(void)&frame_pad;
|
||||
a1v = arg1;
|
||||
a2v = arg2;
|
||||
|
||||
if (!(arg1 & 1)) {
|
||||
dx = (s16) arg2 - (*(s16 **)&D_801909BC)[2];
|
||||
d = dx;
|
||||
denom = -(*(s16 **)&D_801909C8)[2];
|
||||
} else {
|
||||
denom = (*(s16 **)&D_801909C8)[2];
|
||||
d = (*(s16 **)&D_801909BC)[2] - (s16) arg2;
|
||||
dx = -d;
|
||||
}
|
||||
n = -d;
|
||||
{
|
||||
s16 *b8 = *(s16 **)&D_801909C8;
|
||||
u16 *ac = *(u16 **)&D_801909BC;
|
||||
b4 = D_801909C4;
|
||||
b4[0] = ac[0] + n * b8[0] / denom;
|
||||
b4[1] = ac[1] + n * b8[1] / denom;
|
||||
b4[2] = ac[2] + dx;
|
||||
}
|
||||
|
||||
if (b4[0] < M2C_FIELD(arg0, s16 *, 4)) return 0;
|
||||
if (M2C_FIELD(arg0, s16 *, 6) < b4[0]) return 0;
|
||||
if (b4[1] < M2C_FIELD(arg0, s16 *, 8)) return 0;
|
||||
if (M2C_FIELD(arg0, s16 *, 0xA) < b4[1]) return 0;
|
||||
if (a1v & 0x8000) {
|
||||
u16 *b0 = *(u16 **)&D_801909C0;
|
||||
b4[0] = b0[0];
|
||||
b4[1] = b0[1];
|
||||
}
|
||||
D_801152AA = 0;
|
||||
(*(s16 *)D_801152A8) = 0;
|
||||
if (a1v & 1) {
|
||||
D_801909C4[2] = a2v + 2;
|
||||
D_801152AC = 0xFFF;
|
||||
} else {
|
||||
D_801152AC = -0xFFF;
|
||||
D_801909C4[2] = a2v - 2;
|
||||
}
|
||||
(*(s16 *)D_80126720) = (M2C_FIELD(arg0, s16 *, 4) + M2C_FIELD(arg0, s16 *, 6)) >> 1;
|
||||
D_80126722 = (M2C_FIELD(arg0, s16 *, 8) + M2C_FIELD(arg0, s16 *, 0xA)) >> 1;
|
||||
result = 1;
|
||||
D_80126724 = (M2C_FIELD(arg0, s16 *, 0xC) + M2C_FIELD(arg0, s16 *, 0xE)) >> 1;
|
||||
return result;
|
||||
}
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 24 best 2 compiles 811 path R7 do-while @987 + R12 wi
|
||||
g5: verdict NO-MATCH start 24 best 2 compiles 2320 path R12 width a2v s32->u16 @943 + R7 do-while @986
|
||||
s1: verdict NO-MATCH start 24 best 7 compiles 187 path R7 do-while @987 + R14 param-width arg2 s32->u16 @936
|
||||
s2: verdict NO-MATCH start 24 best 7 compiles 187 path R7 do-while @987 + R14 param-width arg2 s32->u16 @936
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R14 param-width arg2 s32->u16 @936 -> 7 (from 14)
|
||||
R14 param-width arg1 s32->u16 @936 -> 12 (from 14)
|
||||
R7 do-while @987 -> 14 (from 24)
|
||||
R6 inline result @994 -> 14 (from 14)
|
||||
R16 const-holder result=1 x1 -> 14 (from 14)
|
||||
R8 hoist tmp0 @971 -> 14 (from 14)
|
||||
R10 param-copy arg0 @951 -> 14 (from 14)
|
||||
R7 block @983 -> 14 (from 14)
|
||||
R4 decl-move a2v 6->0 -> 14 (from 14)
|
||||
R8 hoist tmp0 @970 -> 14 (from 14)
|
||||
R5 swap + @971 -> 14 (from 14)
|
||||
R10 param-copy arg1 @951 -> 14 (from 14)
|
||||
s4: verdict NO-MATCH start 24 best 4 compiles 434 path R7 do-while @987 + R12 width a2v s32->u16 @943 + R12 width a1v s32->u16 @942
|
||||
s7: verdict NO-MATCH start 24 best 4 compiles 561 path R7 do-while @987 + R12 width a2v s32->u16 @943 + R12 width a1v s32->u16 @942
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R12 width a1v s32->u16 @942 -> 4 [REG] (from 6)
|
||||
R12 width a1v s32->s16 @942 -> 4 [REG] (from 6)
|
||||
R12 width a1v s32->u16 @942 -> 4 [REG] (from 6)
|
||||
R12 width a1v s32->s16 @942 -> 4 [REG] (from 6)
|
||||
R12 width a2v s32->u16 @943 -> 6 [REG] (from 14)
|
||||
R12 width a2v s32->s16 @943 -> 6 [REG] (from 14)
|
||||
R6 inline result @994 -> 6 [REG] (from 6)
|
||||
R16 const-holder result=1 x1 -> 6 [REG] (from 6)
|
||||
R8 hoist tmp0 @992 -> 6 [REG] (from 6)
|
||||
R18 bystander @953->951 -> 6 [REG] (from 6)
|
||||
R10 param-copy arg0 @951 -> 6 [REG] (from 6)
|
||||
R7 block @983 -> 6 [REG] (from 6)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 12 best 2 compiles 791 path R7 do-while @833
|
||||
g5: verdict NO-MATCH start 12 best 2 compiles 2273 path R7 do-while @833
|
||||
s1: verdict NO-MATCH start 12 best 2 compiles 192 path R7 do-while @833
|
||||
s2: verdict NO-MATCH start 12 best 2 compiles 192 path R7 do-while @833
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 do-while @833 -> 2 (from 12)
|
||||
R9 swap-stmts @830 -> 2 (from 2)
|
||||
R7 block @830 -> 2 (from 2)
|
||||
R10 param-copy arg0 @829 -> 2 (from 2)
|
||||
R15 sink @866 (sc) -> 2 (from 2)
|
||||
R4 decl-move off 1->0 -> 2 (from 2)
|
||||
R9 swap-stmts @831 -> 2 (from 2)
|
||||
R7 do-while @830 -> 2 (from 2)
|
||||
R12 width off s32->s16 @818 -> 2 (from 2)
|
||||
R10 param-alias e->arg0 @830 -> 2 (from 2)
|
||||
R4 decl-move off 1->2 -> 2 (from 2)
|
||||
R9 swap-stmts @837 -> 2 (from 2)
|
||||
s4: verdict NO-MATCH start 12 best 2 compiles 415 path R18 bystander @835->838
|
||||
s7: verdict NO-MATCH start 12 best 2 compiles 534 path R18 bystander @835->838
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R18 bystander @835->838 -> 2 [ORDER] (from 12)
|
||||
R18 bystander @835->839 -> 2 [ORDER] (from 12)
|
||||
R18 bystander @835->840 -> 2 [ORDER] (from 12)
|
||||
R7 do-while @833 -> 2 [ORDER] (from 12)
|
||||
R18 bystander @837->835 -> 2 [ORDER] (from 12)
|
||||
R9 swap-stmts @830 -> 2 [ORDER] (from 2)
|
||||
R7 block @830 -> 2 [ORDER] (from 2)
|
||||
R12 width sc s32->u16 @822 -> 2 [ORDER] (from 2)
|
||||
R10 param-copy arg0 @829 -> 2 [ORDER] (from 2)
|
||||
R15 sink @866 (sc) -> 2 [ORDER] (from 2)
|
||||
R4 decl-move off 1->0 -> 2 [ORDER] (from 2)
|
||||
R9 swap-stmts @831 -> 2 [ORDER] (from 2)
|
||||
|
||||
@@ -0,0 +1,30 @@
|
||||
s32 func_80139BE0(int param_1)
|
||||
{
|
||||
|
||||
extern unsigned char D_801909F8[];
|
||||
int v;
|
||||
|
||||
if ((*(unsigned int *)(param_1 + 8) & 0x2000) == 0) {
|
||||
int t = *(unsigned char *)(param_1 + 0x22) & 0x60;
|
||||
int h = *(unsigned short *)(param_1 + 0x18);
|
||||
unsigned int idx;
|
||||
|
||||
idx = (unsigned char)t;
|
||||
if (h < 7) {
|
||||
if (h >= 2) {
|
||||
v = D_801909F8[idx >> 5];
|
||||
} else {
|
||||
v = D_801909F8[0];
|
||||
}
|
||||
} else {
|
||||
v = D_801909F8[0];
|
||||
}
|
||||
*(short *)(param_1 + 0x2e) = 3;
|
||||
*(short *)(param_1 + 0x2c) = v;
|
||||
}
|
||||
*(short *)(param_1 + 0x34) = *(short *)(param_1 + 0x2c) * 6;
|
||||
{
|
||||
int x = *(short *)(param_1 + 0x2e);
|
||||
*(short *)(param_1 + 0x36) = x * 12 + (x - 1) * 2;
|
||||
}
|
||||
}
|
||||
@@ -3,16 +3,18 @@ g4s: verdict NO-MATCH start 4 best 4 compiles 419 path
|
||||
g5: verdict NO-MATCH start 4 best 4 compiles 874 path
|
||||
s1: verdict NO-MATCH start 4 best 4 compiles 131 path
|
||||
s2: verdict NO-MATCH start 4 best 4 compiles 131 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R12 width v int->u16 @916 -> 4 (from 4)
|
||||
R6 inline idx @923 -> 4 (from 4)
|
||||
R7 block @923 -> 4 (from 4)
|
||||
R10 param-copy param_1 @917 -> 4 (from 4)
|
||||
R12 width v int->s16 @916 -> 4 (from 4)
|
||||
R6 inline t @919 -> 4 (from 4)
|
||||
R7 do-while @923 -> 4 (from 4)
|
||||
R12 width v int->u8 @916 -> 4 (from 4)
|
||||
R8 temp tmp0 @936 -> 4 (from 4)
|
||||
R7 block @926 -> 4 (from 4)
|
||||
R8 base tmp0 @936 -> 4 (from 4)
|
||||
R7 do-while @926 -> 4 (from 4)
|
||||
s4: verdict NO-MATCH start 4 best 4 compiles 221 path
|
||||
s7: verdict NO-MATCH start 4 best 4 compiles 268 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R12 width v int->u16 @916 -> 4 [COUNT] (from 4)
|
||||
R6 inline idx @923 -> 4 [COUNT] (from 4)
|
||||
R7 block @923 -> 4 [COUNT] (from 4)
|
||||
R10 param-copy param_1 @917 -> 4 [COUNT] (from 4)
|
||||
R12 width v int->s16 @916 -> 4 [COUNT] (from 4)
|
||||
R6 inline t @919 -> 4 [COUNT] (from 4)
|
||||
R7 do-while @923 -> 4 [COUNT] (from 4)
|
||||
R12 width v int->u8 @916 -> 4 [COUNT] (from 4)
|
||||
R8 temp tmp0 @936 -> 4 [COUNT] (from 4)
|
||||
R7 block @926 -> 4 [COUNT] (from 4)
|
||||
R8 base tmp0 @936 -> 4 [COUNT] (from 4)
|
||||
R7 do-while @926 -> 4 [COUNT] (from 4)
|
||||
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 38 best 33 compiles 732 path R7 do-while @1069 + R7 d
|
||||
g5: verdict NO-MATCH start 38 best 33 compiles 1463 path R7 do-while @1069 + R7 do-while @1068 + R7 do-while @1062
|
||||
s1: verdict NO-MATCH start 38 best 34 compiles 188 path R8 temp tmp0 @1068 + R7 do-while @1063
|
||||
s2: verdict NO-MATCH start 38 best 34 compiles 188 path R8 temp tmp0 @1068 + R7 do-while @1063
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 do-while @1063 -> 34 (from 35)
|
||||
R7 do-while @1060 -> 34 (from 35)
|
||||
R8 temp tmp0 @1068 -> 35 (from 38)
|
||||
R12 width tmp0 s32->u16 @1059 -> 35 (from 35)
|
||||
R7 block @1072 -> 35 (from 35)
|
||||
R9 swap-stmts @1072 -> 35 (from 35)
|
||||
R12 width tmp0 s32->s16 @1059 -> 35 (from 35)
|
||||
R8 temp tmp1 @1069 -> 35 (from 35)
|
||||
R9 swap-stmts @1062 -> 35 (from 35)
|
||||
R12 width tmp0 s32->u8 @1059 -> 35 (from 35)
|
||||
R8 base tmp1 @1069 -> 35 (from 35)
|
||||
R7 block @1062 -> 35 (from 35)
|
||||
s4: verdict NO-MATCH start 38 best 34 compiles 437 path R8 temp tmp0 @1068 + R7 do-while @1063
|
||||
s7: verdict NO-MATCH start 38 best 34 compiles 555 path R8 temp tmp0 @1068 + R7 do-while @1063
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 do-while @1063 -> 34 [COUNT] (from 35)
|
||||
R7 do-while @1060 -> 34 [COUNT] (from 35)
|
||||
R12 width tmp0 s32->u16 @1059 -> 34 [COUNT] (from 34)
|
||||
R7 block @1072 -> 34 [COUNT] (from 34)
|
||||
R9 swap-stmts @1072 -> 34 [COUNT] (from 34)
|
||||
R12 width tmp0 s32->s16 @1059 -> 34 [COUNT] (from 34)
|
||||
R8 temp tmp1 @1069 -> 34 [COUNT] (from 34)
|
||||
R12 width tmp0 s32->u8 @1059 -> 34 [COUNT] (from 34)
|
||||
R8 base tmp1 @1069 -> 34 [COUNT] (from 34)
|
||||
R7 block @1062 -> 34 [COUNT] (from 34)
|
||||
R9 swap-stmts @1071 -> 34 [COUNT] (from 34)
|
||||
R7 do-while @1062 -> 34 [COUNT] (from 34)
|
||||
|
||||
@@ -3,16 +3,18 @@ g4s: verdict NO-MATCH start 72 best 72 compiles 513 path
|
||||
g5: verdict NO-MATCH start 72 best 72 compiles 615 path
|
||||
s1: verdict NO-MATCH start 72 best 72 compiles 122 path
|
||||
s2: verdict NO-MATCH start 72 best 72 compiles 122 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 block @1161 -> 72 (from 72)
|
||||
R4 decl-move p 9->0 -> 72 (from 72)
|
||||
R4 decl-move p 9->1 -> 72 (from 72)
|
||||
R7 block @1163 -> 72 (from 72)
|
||||
R4 decl-move p 9->2 -> 72 (from 72)
|
||||
R4 decl-move p 9->3 -> 72 (from 72)
|
||||
R7 block @1165 -> 72 (from 72)
|
||||
R4 decl-move p 9->4 -> 72 (from 72)
|
||||
R4 decl-move p 9->5 -> 72 (from 72)
|
||||
R7 block @1167 -> 72 (from 72)
|
||||
R4 decl-move p 9->6 -> 72 (from 72)
|
||||
R4 decl-move p 9->7 -> 72 (from 72)
|
||||
s4: verdict NO-MATCH start 72 best 72 compiles 198 path
|
||||
s7: verdict NO-MATCH start 72 best 72 compiles 250 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 block @1161 -> 72 [REG] (from 72)
|
||||
R4 decl-move p 9->0 -> 72 [REG] (from 72)
|
||||
R4 decl-move p 9->1 -> 72 [REG] (from 72)
|
||||
R7 block @1163 -> 72 [REG] (from 72)
|
||||
R4 decl-move p 9->2 -> 72 [REG] (from 72)
|
||||
R4 decl-move p 9->3 -> 72 [REG] (from 72)
|
||||
R7 block @1165 -> 72 [REG] (from 72)
|
||||
R4 decl-move p 9->4 -> 72 [REG] (from 72)
|
||||
R4 decl-move p 9->5 -> 72 [REG] (from 72)
|
||||
R7 block @1167 -> 72 [REG] (from 72)
|
||||
R4 decl-move p 9->6 -> 72 [REG] (from 72)
|
||||
R4 decl-move p 9->7 -> 72 [REG] (from 72)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 25 best 19 compiles 583 path R9 swap-stmts @1435 + R9
|
||||
g5: verdict NO-MATCH start 25 best 17 compiles 1136 path R9 swap-stmts @1433 + R12 width c9 s32->s16 @1420 + R6 inline cff @1428 + R7 do-while @1437
|
||||
s1: verdict NO-MATCH start 25 best 20 compiles 186 path R9 swap-stmts @1433 + R9 swap-stmts @1427
|
||||
s2: verdict NO-MATCH start 25 best 20 compiles 184 path R9 swap-stmts @1433 + R9 swap-stmts @1427
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R9 swap-stmts @1427 -> 20 (from 22)
|
||||
R7 do-while @1427 -> 20 (from 22)
|
||||
R16 const-holder c9=9 x1 -> 21 (from 22)
|
||||
R6 inline c9 @1427 -> 21 (from 22)
|
||||
R12 width c9 s32->u16 @1420 -> 21 (from 22)
|
||||
R12 width c9 s32->s16 @1420 -> 21 (from 22)
|
||||
R12 width c9 s32->u8 @1420 -> 21 (from 22)
|
||||
R9 swap-stmts @1440 -> 21 (from 22)
|
||||
R9 swap-stmts @1433 -> 22 (from 25)
|
||||
R7 block @1439 -> 22 (from 22)
|
||||
R4 decl-move psVar2 2->0 -> 22 (from 22)
|
||||
R16 const-holder cff=0xff x1 -> 22 (from 22)
|
||||
s4: verdict NO-MATCH start 25 best 19 compiles 408 path R9 swap-stmts @1433 + R9 swap-stmts @1427 + R18 bystander @1441->1439
|
||||
s7: verdict NO-MATCH start 25 best 19 compiles 519 path R9 swap-stmts @1433 + R9 swap-stmts @1427 + R18 bystander @1441->1439
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R18 bystander @1441->1439 -> 19 [COUNT] (from 20)
|
||||
R9 swap-stmts @1440 -> 19 [COUNT] (from 20)
|
||||
R18 bystander @1441->1439 -> 19 [COUNT] (from 20)
|
||||
R9 swap-stmts @1440 -> 19 [COUNT] (from 20)
|
||||
R18 bystander @1441->1439 -> 19 [COUNT] (from 20)
|
||||
R9 swap-stmts @1440 -> 19 [COUNT] (from 20)
|
||||
R18 bystander @1441->1439 -> 19 [COUNT] (from 20)
|
||||
R9 swap-stmts @1440 -> 19 [COUNT] (from 20)
|
||||
R9 swap-stmts @1427 -> 20 [COUNT] (from 22)
|
||||
R7 do-while @1427 -> 20 [COUNT] (from 22)
|
||||
R9 swap-stmts @1427 -> 20 [COUNT] (from 22)
|
||||
R7 do-while @1427 -> 20 [COUNT] (from 22)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 96 best 69 compiles 827 path R7 do-while @1491 + R7 d
|
||||
g5: verdict NO-MATCH start 96 best 57 compiles 2343 path R12 width uVar3 u32->u8 @1472 + R7 do-while @1489 + R7 do-while @1487 + R6 inline r0 @1481 + R6 inline pa @1520
|
||||
s1: verdict NO-MATCH start 96 best 74 compiles 189 path R12 width uVar3 u32->u8 @1472 + R7 do-while @1489
|
||||
s2: verdict NO-MATCH start 96 best 74 compiles 189 path R12 width uVar3 u32->u8 @1472 + R7 do-while @1489
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 do-while @1489 -> 74 (from 84)
|
||||
R7 do-while @1488 -> 74 (from 84)
|
||||
R6 inline r0 @1481 -> 78 (from 84)
|
||||
R7 do-while @1487 -> 80 (from 88)
|
||||
R6 inline r0 @1481 -> 81 (from 87)
|
||||
R6 inline iVar11 @1484 -> 82 (from 84)
|
||||
R6 inline r0 @1481 -> 82 (from 88)
|
||||
R6 inline mw @1491 -> 83 (from 84)
|
||||
R5 swap * @1493 -> 83 (from 84)
|
||||
R6 inline p1 @1517 -> 83 (from 84)
|
||||
R12 width uVar3 u32->u8 @1472 -> 84 (from 96)
|
||||
R7 block @1474 -> 84 (from 84)
|
||||
s4: verdict NO-MATCH start 96 best 66 compiles 440 path R12 width uVar3 u32->u8 @1472 + R7 do-while @1489 + R7 do-while @1487
|
||||
s7: verdict NO-MATCH start 96 best 66 compiles 565 path R12 width uVar3 u32->u8 @1472 + R7 do-while @1489 + R7 do-while @1487
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 do-while @1487 -> 66 [COUNT] (from 74)
|
||||
R6 inline r0 @1481 -> 68 [COUNT] (from 74)
|
||||
R6 inline r0 @1481 -> 68 [COUNT] (from 74)
|
||||
R6 inline r0 @1481 -> 69 [COUNT] (from 75)
|
||||
R7 do-while @1488 -> 71 [COUNT] (from 74)
|
||||
R7 do-while @1487 -> 71 [COUNT] (from 74)
|
||||
R7 do-while @1486 -> 71 [COUNT] (from 74)
|
||||
R7 do-while @1491 -> 71 [COUNT] (from 78)
|
||||
R6 inline iVar11 @1484 -> 72 [COUNT] (from 74)
|
||||
R6 inline pa @1522 -> 72 [COUNT] (from 74)
|
||||
R6 inline pb @1523 -> 72 [COUNT] (from 74)
|
||||
R6 inline iVar11 @1484 -> 72 [COUNT] (from 74)
|
||||
|
||||
@@ -0,0 +1,68 @@
|
||||
void func_8013DD68() {
|
||||
extern void SetDrawEnv(void *p, void *env);
|
||||
extern u16 D_800AF7B8;
|
||||
extern u8 D_800BA0E4[];
|
||||
extern u8 D_80190DD0[];
|
||||
|
||||
u32 *p;
|
||||
u16 uVar1;
|
||||
u16 *puVar16;
|
||||
u16 *q;
|
||||
u16 *puVar10;
|
||||
u16 uVar2;
|
||||
int uVar5;
|
||||
int iVar14;
|
||||
Buf_8013DD68 buf;
|
||||
u8 *pbase;
|
||||
u8 *base;
|
||||
|
||||
pbase = D_800AF630;
|
||||
puVar16 = (*(u16 * *)&D_801EDABC);
|
||||
p = (*(u32 * *)&D_800A5E60);
|
||||
uVar1 = *puVar16;
|
||||
puVar16 = puVar16 + 1;
|
||||
base = pbase + (u32)D_800AF7B8 * 0x5C;
|
||||
buf.env = *(DrawEnv_8013DD68 *)(base + 0x38);
|
||||
*((u8 *)&buf + 0x18) = 0;
|
||||
SetDrawEnv(p, &buf);
|
||||
((P_TAG_8013DD68 *)p)->addr = OTE->addr;
|
||||
OTE->addr = (u32)p;
|
||||
p = p + 0x10;
|
||||
iVar14 = 0;
|
||||
if (uVar1 != 0) {
|
||||
int c5 = 5;
|
||||
puVar10 = (u16 *)((int)p + 0x18);
|
||||
q = puVar16 + 8;
|
||||
do {
|
||||
*(u8 *)((int)puVar10 + -0x15) = c5;
|
||||
uVar2 = q[-6];
|
||||
*(u8 *)((int)puVar10 + -0xd) = 100;
|
||||
*(u8 *)((int)puVar10 + -0x10) = (u8)(*(int*)&D_801EDAEC);
|
||||
*(u8 *)((int)puVar10 + -0xf) = (u8)(*(int*)&D_801EDAF0);
|
||||
uVar5 = (*(int*)&D_801EDAF4);
|
||||
*(u32 *)((int)puVar10 + -0x14) = uVar2 & 0x9ff | 0xe1000400;
|
||||
*(u8 *)((int)puVar10 + -0xe) = (u8)uVar5;
|
||||
*(u16 *)((int)puVar10 + -0xc) = q[-4];
|
||||
iVar14 = iVar14 + 1;
|
||||
*(u16 *)((int)puVar10 + -0xa) = q[-3];
|
||||
*(u8 *)((int)puVar10 + -8) = (u8)*puVar16;
|
||||
uVar2 = q[-7];
|
||||
*(u16 *)((int)puVar10 + -6) = 0x7800;
|
||||
*(u8 *)((int)puVar10 + -7) = (u8)uVar2;
|
||||
puVar16 = puVar16 + 8;
|
||||
*(u16 *)((int)puVar10 + -4) = q[-2];
|
||||
*(u16 *)((int)puVar10 + -2) = q[-1];
|
||||
((P_TAG_8013DD68 *)p)->addr = OTE->addr;
|
||||
puVar10 = puVar10 + 0xc;
|
||||
OTE->addr = (u32)p;
|
||||
p = p + 6;
|
||||
q = q + 8;
|
||||
} while (iVar14 < (int)(u32)uVar1);
|
||||
}
|
||||
SetDrawEnv(p, D_80190DD0);
|
||||
((P_TAG_8013DD68 *)p)->addr = OTE->addr;
|
||||
OTE->addr = (u32)p;
|
||||
p = p + 0x10;
|
||||
(*(u32 * *)&D_800A5E60) = p;
|
||||
return;
|
||||
}
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 17 best 11 compiles 816 path R6 inline uVar2 @1733 +
|
||||
g5: verdict NO-MATCH start 17 best 7 compiles 2280 path R6 inline uVar2 @1731 + R7 do-while @1728 + R9 swap-stmts @1731
|
||||
s1: verdict NO-MATCH start 17 best 14 compiles 189 path R6 inline uVar2 @1731
|
||||
s2: verdict NO-MATCH start 17 best 14 compiles 189 path R6 inline uVar2 @1731
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R6 inline uVar2 @1731 -> 14 (from 17)
|
||||
R7 block @1720 -> 14 (from 14)
|
||||
R2 decl-order 1,0 -> 14 (from 14)
|
||||
R4 decl-move uVar2 8->0 -> 14 (from 14)
|
||||
R4 decl-move uVar2 8->1 -> 14 (from 14)
|
||||
R7 block @1711 -> 14 (from 14)
|
||||
R4 decl-move uVar2 8->2 -> 14 (from 14)
|
||||
R9 swap-stmts @1733 -> 14 (from 14)
|
||||
R4 decl-move uVar2 8->3 -> 14 (from 14)
|
||||
R7 block @1723 -> 14 (from 14)
|
||||
R4 decl-move uVar2 8->4 -> 14 (from 14)
|
||||
R9 swap-stmts @1728 -> 14 (from 14)
|
||||
s4: verdict NO-MATCH start 17 best 14 compiles 441 path R6 inline uVar2 @1731
|
||||
s7: verdict NO-MATCH start 17 best 14 compiles 562 path R6 inline uVar2 @1731
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R6 inline uVar2 @1731 -> 14 [COUNT] (from 17)
|
||||
R18 bystander @1701->1704 -> 14 [COUNT] (from 14)
|
||||
R7 block @1720 -> 14 [COUNT] (from 14)
|
||||
R2 decl-order 1,0 -> 14 [COUNT] (from 14)
|
||||
R4 decl-move uVar2 8->0 -> 14 [COUNT] (from 14)
|
||||
R18 bystander @1701->1705 -> 14 [COUNT] (from 14)
|
||||
R4 decl-move uVar2 8->1 -> 14 [COUNT] (from 14)
|
||||
R18 bystander @1703->1701 -> 14 [COUNT] (from 14)
|
||||
R7 block @1711 -> 14 [COUNT] (from 14)
|
||||
R4 decl-move uVar2 8->2 -> 14 [COUNT] (from 14)
|
||||
R9 swap-stmts @1733 -> 14 [COUNT] (from 14)
|
||||
R4 decl-move uVar2 8->3 -> 14 [COUNT] (from 14)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 70 best 16 compiles 810 path R12 width pad u16->s32 @
|
||||
g5: verdict NO-MATCH start 70 best 16 compiles 2325 path R12 width pad u16->s32 @983 + R6 inline p3e @1148 + R8 hoist tmp0 @1149 + R7 do-while @1000
|
||||
s1: verdict NO-MATCH start 70 best 70 compiles 188 path
|
||||
s2: verdict NO-MATCH start 70 best 70 compiles 188 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R3 init-split pd -> 70 (from 70)
|
||||
R7 block @1024 -> 70 (from 70)
|
||||
R5 swap + @1150 -> 70 (from 70)
|
||||
R2 decl-order 1,0 -> 70 (from 70)
|
||||
R4 decl-move pd 0->1 -> 70 (from 70)
|
||||
R5 swap + @1151 -> 70 (from 70)
|
||||
R4 decl-move pd 0->2 -> 70 (from 70)
|
||||
R7 block @1035 -> 70 (from 70)
|
||||
R9 swap-stmts @1055 -> 70 (from 70)
|
||||
R4 decl-move pd 0->3 -> 70 (from 70)
|
||||
R8 hoist tmp0 @1041 -> 70 (from 70)
|
||||
R7 do-while @1035 -> 70 (from 70)
|
||||
s4: verdict NO-MATCH start 70 best 70 compiles 437 path
|
||||
s7: verdict NO-MATCH start 70 best 70 compiles 557 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R3 init-split pd -> 70 [COUNT] (from 70)
|
||||
R7 block @1024 -> 70 [COUNT] (from 70)
|
||||
R5 swap + @1150 -> 70 [COUNT] (from 70)
|
||||
R2 decl-order 1,0 -> 70 [COUNT] (from 70)
|
||||
R4 decl-move pd 0->1 -> 70 [COUNT] (from 70)
|
||||
R5 swap + @1151 -> 70 [COUNT] (from 70)
|
||||
R4 decl-move pd 0->2 -> 70 [COUNT] (from 70)
|
||||
R7 block @1035 -> 70 [COUNT] (from 70)
|
||||
R9 swap-stmts @1055 -> 70 [COUNT] (from 70)
|
||||
R4 decl-move pd 0->3 -> 70 [COUNT] (from 70)
|
||||
R8 hoist tmp0 @1041 -> 70 [COUNT] (from 70)
|
||||
R7 do-while @1035 -> 70 [COUNT] (from 70)
|
||||
|
||||
@@ -4,16 +4,18 @@ s1: verdict NO-MATCH start 43 best 34 compiles 186 path R9 swap-stmts @1102 + R7
|
||||
s2: verdict NO-MATCH start 43 best 34 compiles 186 path R9 swap-stmts @1102 + R7 do-while @1101
|
||||
s3: verdict BUDGET start 43 best 30 compiles 400 path R9 swap-stmts @1102 + R7 do-while @1101 + R5 swap | @1141
|
||||
s3b: verdict BUDGET start 43 best 30 compiles 400 path R9 swap-stmts @1102 + R7 do-while @1101 + R5 swap | @1141
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R5 swap | @1141 -> 30 (from 34)
|
||||
R9 swap-stmts @1132 -> 30 (from 34)
|
||||
R9 swap-stmts @1105 -> 33 (from 34)
|
||||
R7 do-while @1101 -> 34 (from 43)
|
||||
R12 width eight s32->u16 @1049 -> 34 (from 34)
|
||||
R8 hoist tmp0 @1116 -> 34 (from 34)
|
||||
R7 block @1131 -> 34 (from 34)
|
||||
R12 width eight s32->s16 @1049 -> 34 (from 34)
|
||||
R7 block @1129 -> 34 (from 34)
|
||||
R8 hoist tmp0 @1133 -> 34 (from 34)
|
||||
R4 decl-move eight 25->3 -> 34 (from 34)
|
||||
R8 hoist tmp0 @1126 -> 34 (from 34)
|
||||
s4: verdict NO-MATCH start 43 best 30 compiles 434 path R9 swap-stmts @1102 + R7 do-while @1101 + R5 swap | @1141
|
||||
s7: verdict NO-MATCH start 43 best 30 compiles 552 path R9 swap-stmts @1102 + R7 do-while @1101 + R5 swap | @1141
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R5 swap | @1141 -> 30 [COUNT] (from 34)
|
||||
R9 swap-stmts @1132 -> 30 [COUNT] (from 34)
|
||||
R5 swap | @1141 -> 30 [COUNT] (from 34)
|
||||
R9 swap-stmts @1132 -> 30 [COUNT] (from 34)
|
||||
R5 swap | @1141 -> 30 [COUNT] (from 34)
|
||||
R9 swap-stmts @1132 -> 30 [COUNT] (from 34)
|
||||
R5 swap | @1141 -> 31 [COUNT] (from 35)
|
||||
R9 swap-stmts @1132 -> 31 [COUNT] (from 35)
|
||||
R7 do-while @1101 -> 34 [COUNT] (from 43)
|
||||
R18 bystander @1101->1104 -> 34 [COUNT] (from 43)
|
||||
R18 bystander @1101->1105 -> 34 [COUNT] (from 43)
|
||||
R12 width eight s32->u16 @1049 -> 34 [COUNT] (from 34)
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
void func_80141874(void) {
|
||||
|
||||
extern u16 D_8011511C;
|
||||
extern u16 D_80115116;
|
||||
extern void (*D_8019182C[])(void);
|
||||
void (*fp)(void);
|
||||
func_801754A8();
|
||||
D_8011511E = func_80014ED4(0);
|
||||
D_8011511C = func_80015018(0);
|
||||
fp = D_8019182C[D_80115112];
|
||||
fp();
|
||||
func_80141C04();
|
||||
D_80115116 += 1;
|
||||
}
|
||||
@@ -3,16 +3,18 @@ g4s: verdict NO-MATCH start 6 best 6 compiles 234 path
|
||||
g5: verdict NO-MATCH start 6 best 6 compiles 328 path
|
||||
s1: verdict NO-MATCH start 6 best 6 compiles 83 path
|
||||
s2: verdict NO-MATCH start 6 best 6 compiles 83 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R6 inline fp @1357 -> 6 (from 6)
|
||||
R7 block @1355 -> 6 (from 6)
|
||||
R7 do-while @1355 -> 6 (from 6)
|
||||
R7 block @1354 -> 6 (from 6)
|
||||
R7 do-while @1354 -> 6 (from 6)
|
||||
R7 block @1356 -> 6 (from 6)
|
||||
R7 block @1357 -> 6 (from 6)
|
||||
R7 block @1358 -> 6 (from 6)
|
||||
R7 do-while @1358 -> 6 (from 6)
|
||||
R7 block @1359 -> 6 (from 6)
|
||||
R7 do-while @1359 -> 6 (from 6)
|
||||
R7 block @1360 -> 6 (from 6)
|
||||
s4: verdict NO-MATCH start 6 best 6 compiles 223 path
|
||||
s7: verdict NO-MATCH start 6 best 6 compiles 279 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R6 inline fp @1357 -> 6 [COUNT] (from 6)
|
||||
R7 block @1355 -> 6 [COUNT] (from 6)
|
||||
R7 do-while @1355 -> 6 [COUNT] (from 6)
|
||||
R7 block @1354 -> 6 [COUNT] (from 6)
|
||||
R7 do-while @1354 -> 6 [COUNT] (from 6)
|
||||
R7 block @1356 -> 6 [COUNT] (from 6)
|
||||
R7 block @1357 -> 6 [COUNT] (from 6)
|
||||
R7 block @1358 -> 6 [COUNT] (from 6)
|
||||
R7 do-while @1358 -> 6 [COUNT] (from 6)
|
||||
R7 block @1359 -> 6 [COUNT] (from 6)
|
||||
R7 do-while @1359 -> 6 [COUNT] (from 6)
|
||||
R7 block @1360 -> 6 [COUNT] (from 6)
|
||||
|
||||
@@ -0,0 +1,36 @@
|
||||
void func_80143D28(s32 param_1) {
|
||||
|
||||
extern MatEntry D_80191D88[];
|
||||
s32 iVar3 = *(s32 *)(param_1 + 0x20);
|
||||
s32 iVar2 = *(s32 *)(param_1 + 0x64); /* $s1 */
|
||||
MatEntry *p = &D_80191D88[*(s16 *)(param_1 + 0x70)];
|
||||
s32 sVar4;
|
||||
s32 iVar1;
|
||||
|
||||
*(s16 *)(iVar3 + 0x14) = p->f8;
|
||||
*(u16 *)(iVar3 + 0x12) = *(u16 *)(iVar3 + 0x12) + p->fa;
|
||||
sVar4 = 0x1000;
|
||||
((void (*)(void *, void *, void *))ApplyMatrixSV)((void *)(*(s32 *)(param_1 + 0x20) + 0x34), p, (void *)(param_1 + 0x50));
|
||||
|
||||
if (*(s16 *)(param_1 + 0xfe) == 0 &&
|
||||
(iVar2 == 0 || *(s16 *)(iVar2 + 0x36) != *(s16 *)(param_1 + 0xfc) ||
|
||||
*(u8 *)(iVar2 + 0xc1) != 6)) {
|
||||
if (0x10 < *(s32 *)(param_1 + 0x1c)) {
|
||||
*(s32 *)(param_1 + 0x1c) = 0x10;
|
||||
}
|
||||
*(s16 *)(param_1 + 0xfe) = 1;
|
||||
}
|
||||
|
||||
iVar1 = *(s32 *)(param_1 + 0x1c);
|
||||
if (iVar1 < 0x11) {
|
||||
sVar4 = iVar1 << 8;
|
||||
}
|
||||
if (0x73 < iVar1) {
|
||||
sVar4 = (0x78 - iVar1) << 10;
|
||||
}
|
||||
*(s16 *)(iVar3 + 0x18) = *(s16 *)(iVar3 + 0x1a) = *(s16 *)(iVar3 + 0x1c) = sVar4;
|
||||
|
||||
if (func_8012BEE8(param_1)) {
|
||||
func_8012C218((void *)param_1);
|
||||
}
|
||||
}
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 11 best 5 compiles 765 path R8 temp tmp0 @2120
|
||||
g5: verdict NO-MATCH start 11 best 5 compiles 1805 path R8 temp tmp0 @2120
|
||||
s1: verdict NO-MATCH start 11 best 10 compiles 189 path R9 swap-stmts @2108
|
||||
s2: verdict NO-MATCH start 11 best 10 compiles 189 path R9 swap-stmts @2108
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R9 swap-stmts @2108 -> 10 (from 11)
|
||||
R8 hoist tmp0 @2125 -> 10 (from 10)
|
||||
R3 init-split iVar3 -> 10 (from 10)
|
||||
R7 block @2122 -> 10 (from 10)
|
||||
R4 decl-move iVar3 1->0 -> 10 (from 10)
|
||||
R7 do-while @2122 -> 10 (from 10)
|
||||
R4 decl-move iVar3 1->2 -> 10 (from 10)
|
||||
R8 base tmp0 @2127 -> 10 (from 10)
|
||||
R7 block @2125 -> 10 (from 10)
|
||||
R4 decl-move iVar3 1->3 -> 10 (from 10)
|
||||
R7 do-while @2125 -> 10 (from 10)
|
||||
R4 decl-move iVar3 1->4 -> 10 (from 10)
|
||||
s4: verdict NO-MATCH start 11 best 5 compiles 434 path R8 temp tmp0 @2120
|
||||
s7: verdict NO-MATCH start 11 best 5 compiles 556 path R8 temp tmp0 @2120
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R8 temp tmp0 @2120 -> 5 [COUNT] (from 11)
|
||||
R8 hoist tmp1 @2127 -> 5 [COUNT] (from 5)
|
||||
R3 init-split iVar3 -> 5 [COUNT] (from 5)
|
||||
R18 bystander @2109->2107 -> 5 [COUNT] (from 5)
|
||||
R7 block @2124 -> 5 [COUNT] (from 5)
|
||||
R4 decl-move iVar3 1->0 -> 5 [COUNT] (from 5)
|
||||
R4 decl-move iVar3 1->2 -> 5 [COUNT] (from 5)
|
||||
R8 base tmp1 @2121 -> 5 [COUNT] (from 5)
|
||||
R7 block @2122 -> 5 [COUNT] (from 5)
|
||||
R9 swap-stmts @2108 -> 5 [COUNT] (from 5)
|
||||
R4 decl-move iVar3 1->3 -> 5 [COUNT] (from 5)
|
||||
R4 decl-move iVar3 1->4 -> 5 [COUNT] (from 5)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 11 best 11 compiles 400 path
|
||||
g5: verdict NO-MATCH start 11 best 11 compiles 725 path
|
||||
s1: verdict NO-MATCH start 11 best 11 compiles 143 path
|
||||
s2: verdict NO-MATCH start 11 best 11 compiles 143 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 block @32 -> 11 (from 11)
|
||||
R7 do-while @32 -> 11 (from 11)
|
||||
R7 block @34 -> 11 (from 11)
|
||||
R7 do-while @34 -> 11 (from 11)
|
||||
R7 block @48 -> 11 (from 11)
|
||||
R7 do-while @48 -> 11 (from 11)
|
||||
R7 block @40 -> 11 (from 11)
|
||||
R7 do-while @40 -> 11 (from 11)
|
||||
R7 block @42 -> 11 (from 11)
|
||||
R7 do-while @42 -> 11 (from 11)
|
||||
R7 block @46 -> 11 (from 11)
|
||||
R7 do-while @46 -> 11 (from 11)
|
||||
s4: verdict NO-MATCH start 11 best 11 compiles 238 path
|
||||
s7: verdict NO-MATCH start 11 best 11 compiles 301 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 block @32 -> 11 [COUNT] (from 11)
|
||||
R7 do-while @32 -> 11 [COUNT] (from 11)
|
||||
R7 block @34 -> 11 [COUNT] (from 11)
|
||||
R7 do-while @34 -> 11 [COUNT] (from 11)
|
||||
R7 block @48 -> 11 [COUNT] (from 11)
|
||||
R7 do-while @48 -> 11 [COUNT] (from 11)
|
||||
R7 block @40 -> 11 [COUNT] (from 11)
|
||||
R7 do-while @40 -> 11 [COUNT] (from 11)
|
||||
R7 block @42 -> 11 [COUNT] (from 11)
|
||||
R7 do-while @42 -> 11 [COUNT] (from 11)
|
||||
R7 block @46 -> 11 [COUNT] (from 11)
|
||||
R7 do-while @46 -> 11 [COUNT] (from 11)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 11 best 11 compiles 400 path
|
||||
g5: verdict NO-MATCH start 11 best 11 compiles 731 path
|
||||
s1: verdict NO-MATCH start 11 best 11 compiles 143 path
|
||||
s2: verdict NO-MATCH start 11 best 11 compiles 143 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 block @82 -> 11 (from 11)
|
||||
R7 do-while @82 -> 11 (from 11)
|
||||
R7 block @84 -> 11 (from 11)
|
||||
R7 do-while @84 -> 11 (from 11)
|
||||
R7 block @90 -> 11 (from 11)
|
||||
R7 do-while @90 -> 11 (from 11)
|
||||
R7 block @96 -> 11 (from 11)
|
||||
R7 do-while @96 -> 11 (from 11)
|
||||
R7 block @88 -> 11 (from 11)
|
||||
R7 do-while @88 -> 11 (from 11)
|
||||
R7 block @92 -> 11 (from 11)
|
||||
R7 do-while @92 -> 11 (from 11)
|
||||
s4: verdict NO-MATCH start 11 best 11 compiles 238 path
|
||||
s7: verdict NO-MATCH start 11 best 11 compiles 301 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 block @82 -> 11 [COUNT] (from 11)
|
||||
R7 do-while @82 -> 11 [COUNT] (from 11)
|
||||
R7 block @84 -> 11 [COUNT] (from 11)
|
||||
R7 do-while @84 -> 11 [COUNT] (from 11)
|
||||
R7 block @90 -> 11 [COUNT] (from 11)
|
||||
R7 do-while @90 -> 11 [COUNT] (from 11)
|
||||
R7 block @96 -> 11 [COUNT] (from 11)
|
||||
R7 do-while @96 -> 11 [COUNT] (from 11)
|
||||
R7 block @88 -> 11 [COUNT] (from 11)
|
||||
R7 do-while @88 -> 11 [COUNT] (from 11)
|
||||
R7 block @92 -> 11 [COUNT] (from 11)
|
||||
R7 do-while @92 -> 11 [COUNT] (from 11)
|
||||
|
||||
@@ -5,16 +5,18 @@ s1: verdict NO-MATCH start 23 best 18 compiles 178 path R9 swap-stmts @663 + R12
|
||||
s2: verdict NO-MATCH start 23 best 18 compiles 178 path R9 swap-stmts @663 + R12 width tmp s32->u8 @642
|
||||
s3: verdict NO-MATCH start 23 best 18 compiles 300 path R9 swap-stmts @663 + R12 width tmp s32->u8 @642
|
||||
s3b: verdict NO-MATCH start 23 best 18 compiles 300 path R9 swap-stmts @663 + R12 width tmp s32->u8 @642
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R12 width tmp s32->u8 @642 -> 18 (from 20)
|
||||
R12 width bVar1 u8->s32 @645 -> 18 (from 18)
|
||||
R6 inline lo @660 -> 18 (from 18)
|
||||
R8 temp tmp0 @659 -> 18 (from 18)
|
||||
R7 block @659 -> 18 (from 18)
|
||||
R10 param-copy a0 @646 -> 18 (from 18)
|
||||
R12 width bVar1 u8->u16 @645 -> 18 (from 18)
|
||||
R8 base tmp0 @659 -> 18 (from 18)
|
||||
R12 width bVar1 u8->s16 @645 -> 18 (from 18)
|
||||
R8 base-shared tmp0 @659 -> 18 (from 18)
|
||||
R7 block @660 -> 18 (from 18)
|
||||
R9 swap-stmts @646 -> 18 (from 18)
|
||||
s4: verdict NO-MATCH start 23 best 18 compiles 300 path R9 swap-stmts @663 + R12 width tmp s32->u8 @642
|
||||
s7: verdict NO-MATCH start 23 best 18 compiles 390 path R9 swap-stmts @663 + R12 width tmp s32->u8 @642
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R12 width tmp s32->u8 @642 -> 18 [COUNT] (from 20)
|
||||
R12 width bVar1 u8->s32 @645 -> 18 [COUNT] (from 18)
|
||||
R6 inline lo @660 -> 18 [COUNT] (from 18)
|
||||
R8 temp tmp0 @659 -> 18 [COUNT] (from 18)
|
||||
R7 block @659 -> 18 [COUNT] (from 18)
|
||||
R10 param-copy a0 @646 -> 18 [COUNT] (from 18)
|
||||
R12 width bVar1 u8->u16 @645 -> 18 [COUNT] (from 18)
|
||||
R8 base tmp0 @659 -> 18 [COUNT] (from 18)
|
||||
R12 width bVar1 u8->s16 @645 -> 18 [COUNT] (from 18)
|
||||
R8 base-shared tmp0 @659 -> 18 [COUNT] (from 18)
|
||||
R7 block @660 -> 18 [COUNT] (from 18)
|
||||
R9 swap-stmts @646 -> 18 [COUNT] (from 18)
|
||||
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 6 best 6 compiles 352 path
|
||||
g5: verdict NO-MATCH start 6 best 6 compiles 723 path
|
||||
s1: verdict NO-MATCH start 6 best 6 compiles 148 path
|
||||
s2: verdict NO-MATCH start 6 best 6 compiles 148 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R12 width a s32->u16 @720 -> 6 (from 6)
|
||||
R6 inline ang @729 -> 6 (from 6)
|
||||
R7 block @729 -> 6 (from 6)
|
||||
R9 swap-stmts @728 -> 6 (from 6)
|
||||
R4 decl-move a 6->0 -> 6 (from 6)
|
||||
R12 width a s32->s16 @720 -> 6 (from 6)
|
||||
R4 decl-move a 6->1 -> 6 (from 6)
|
||||
R6 inline res @751 -> 6 (from 6)
|
||||
R8 hoist tmp0 @751 -> 6 (from 6)
|
||||
R4 decl-move a 6->2 -> 6 (from 6)
|
||||
R4 decl-move a 6->3 -> 6 (from 6)
|
||||
R12 width d s32->s16 @723 -> 6 (from 6)
|
||||
s4: verdict NO-MATCH start 6 best 6 compiles 258 path
|
||||
s7: verdict NO-MATCH start 6 best 6 compiles 324 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R12 width a s32->u16 @720 -> 6 [COUNT] (from 6)
|
||||
R6 inline ang @729 -> 6 [COUNT] (from 6)
|
||||
R7 block @729 -> 6 [COUNT] (from 6)
|
||||
R9 swap-stmts @728 -> 6 [COUNT] (from 6)
|
||||
R4 decl-move a 6->0 -> 6 [COUNT] (from 6)
|
||||
R12 width a s32->s16 @720 -> 6 [COUNT] (from 6)
|
||||
R4 decl-move a 6->1 -> 6 [COUNT] (from 6)
|
||||
R6 inline res @751 -> 6 [COUNT] (from 6)
|
||||
R8 hoist tmp0 @751 -> 6 [COUNT] (from 6)
|
||||
R4 decl-move a 6->2 -> 6 [COUNT] (from 6)
|
||||
R4 decl-move a 6->3 -> 6 [COUNT] (from 6)
|
||||
R12 width d s32->s16 @723 -> 6 [COUNT] (from 6)
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
s32 func_80148E54(s32 arg0) {
|
||||
|
||||
extern s32 D_801151D4;
|
||||
extern s16 (*D_80191FA4[])();
|
||||
s32 tmp = (ratan2(*(s32 *)(D_801151D4 + 0x44) - *(s32 *)(D_801151D4 + 0x50), // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B t3_tus1)
|
||||
*(s32 *)(D_801151D4 + 0x48) - *(s32 *)(D_801151D4 + 0x3C)) - 0x400) & 0xFFF;
|
||||
s32 ang;
|
||||
ang = tmp;
|
||||
|
||||
switch (*(u8 *)(arg0 + 0xA9)) {
|
||||
case 0x41:
|
||||
return D_80191FA4[*(u16 *)(arg0 + 0xAA) >> 12]();
|
||||
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;
|
||||
}
|
||||
}
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 6 best 6 compiles 167 path
|
||||
g5: verdict NO-MATCH start 6 best 4 compiles 445 path R10 param-copy arg0 @770 + R14 param-width arg0 s32->u16 @763
|
||||
s1: verdict NO-MATCH start 6 best 6 compiles 63 path
|
||||
s2: verdict NO-MATCH start 6 best 6 compiles 63 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R12 width tmp s32->u16 @767 -> 6 (from 6)
|
||||
R6 inline ang @770 -> 6 (from 6)
|
||||
R7 block @770 -> 6 (from 6)
|
||||
R10 param-copy arg0 @770 -> 6 (from 6)
|
||||
R12 width tmp s32->s16 @767 -> 6 (from 6)
|
||||
R7 do-while @770 -> 6 (from 6)
|
||||
R12 width ang s32->u16 @769 -> 6 (from 6)
|
||||
R12 width ang s32->s16 @769 -> 6 (from 6)
|
||||
R6 inline ang @770 -> 6 (from 6)
|
||||
R7 block @770 -> 6 (from 6)
|
||||
R10 param-copy arg0 @770 -> 6 (from 6)
|
||||
R7 do-while @770 -> 6 (from 6)
|
||||
s4: verdict NO-MATCH start 6 best 4 compiles 110 path R12 width tmp s32->u16 @767 + R10 param-copy arg0 @770 + R14 param-width arg0 s32->u16 @763
|
||||
s7: verdict NO-MATCH start 6 best 4 compiles 156 path R10 param-copy arg0 @770 + R14 param-width arg0 s32->u16 @763
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R14 param-width arg0 s32->u16 @763 -> 4 [COUNT] (from 6)
|
||||
R14 param-width arg0 s32->u8 @763 -> 4 [COUNT] (from 6)
|
||||
R12 width ang s32->u16 @769 -> 4 [COUNT] (from 4)
|
||||
R6 inline ang @772 -> 4 [COUNT] (from 4)
|
||||
R9 swap-stmts @771 -> 4 [COUNT] (from 4)
|
||||
R10 param-copy arg0 @771 -> 4 [COUNT] (from 4)
|
||||
R12 width ang s32->s16 @769 -> 4 [COUNT] (from 4)
|
||||
R7 block @771 -> 4 [COUNT] (from 4)
|
||||
R7 do-while @771 -> 4 [COUNT] (from 4)
|
||||
R7 block @772 -> 4 [COUNT] (from 4)
|
||||
R7 do-while @772 -> 4 [COUNT] (from 4)
|
||||
R12 width tmp s32->u16 @767 -> 4 [COUNT] (from 4)
|
||||
|
||||
@@ -3,16 +3,18 @@ g4s: verdict NO-MATCH start 8 best 8 compiles 801 path
|
||||
g5: verdict NO-MATCH start 8 best 8 compiles 2315 path
|
||||
s1: verdict NO-MATCH start 8 best 8 compiles 190 path
|
||||
s2: verdict NO-MATCH start 8 best 8 compiles 190 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 block @1770 -> 8 (from 8)
|
||||
R6 inline new_var2 @1773 -> 8 (from 8)
|
||||
R8 hoist tmp0 @1780 -> 8 (from 8)
|
||||
R7 block @1779 -> 8 (from 8)
|
||||
R5 swap + @1774 -> 8 (from 8)
|
||||
R7 do-while @1779 -> 8 (from 8)
|
||||
R8 hoist tmp0 @1767 -> 8 (from 8)
|
||||
R7 block @1771 -> 8 (from 8)
|
||||
R10 param-alias a2->a2x @1641 -> 8 (from 8)
|
||||
R6 inline r2 @1677 -> 8 (from 8)
|
||||
R7 do-while @1771 -> 8 (from 8)
|
||||
R6 inline r3 @1678 -> 8 (from 8)
|
||||
s4: verdict NO-MATCH start 8 best 8 compiles 428 path
|
||||
s7: verdict NO-MATCH start 8 best 8 compiles 549 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 block @1770 -> 8 [COUNT] (from 8)
|
||||
R6 inline new_var2 @1773 -> 8 [COUNT] (from 8)
|
||||
R18 bystander @1645->1641 -> 8 [COUNT] (from 8)
|
||||
R8 hoist tmp0 @1780 -> 8 [COUNT] (from 8)
|
||||
R18 bystander @1645->1642 -> 8 [COUNT] (from 8)
|
||||
R7 block @1779 -> 8 [COUNT] (from 8)
|
||||
R5 swap + @1774 -> 8 [COUNT] (from 8)
|
||||
R18 bystander @1645->1643 -> 8 [COUNT] (from 8)
|
||||
R7 do-while @1779 -> 8 [COUNT] (from 8)
|
||||
R8 hoist tmp0 @1767 -> 8 [COUNT] (from 8)
|
||||
R18 bystander @1645->1644 -> 8 [COUNT] (from 8)
|
||||
R7 block @1771 -> 8 [COUNT] (from 8)
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
void func_80157D20(void)
|
||||
{
|
||||
|
||||
extern u16 D_80192768[];
|
||||
void *a0v;
|
||||
s32 a1v;
|
||||
void *param_1 = a0v;
|
||||
s32 param_2 = a1v;
|
||||
|
||||
((void (*)(void))func_80156648)();
|
||||
((void (*)(void *, s32))func_80147078)(param_1, D_80192768[param_2]);
|
||||
((void (*)(void *))func_80157D74)(param_1);
|
||||
}
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 9 best 4 compiles 180 path R12 width a1v s32->u16 @13
|
||||
g5: verdict NO-MATCH start 9 best 4 compiles 342 path R12 width a1v s32->u16 @1371
|
||||
s1: verdict NO-MATCH start 9 best 4 compiles 77 path R12 width a1v s32->u16 @1365
|
||||
s2: verdict NO-MATCH start 9 best 4 compiles 77 path R12 width a1v s32->u16 @1365
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R12 width a1v s32->u16 @1365 -> 4 (from 9)
|
||||
R12 width a1v s32->u8 @1365 -> 4 (from 9)
|
||||
R12 width param_2 s32->u16 @1367 -> 4 (from 9)
|
||||
R12 width param_2 s32->u8 @1367 -> 4 (from 9)
|
||||
R7 block @1369 -> 4 (from 4)
|
||||
R2 decl-order 1,0 -> 4 (from 4)
|
||||
R4 decl-move a0v 1->0 -> 4 (from 4)
|
||||
R7 do-while @1369 -> 4 (from 4)
|
||||
R7 block @1370 -> 4 (from 4)
|
||||
R7 do-while @1370 -> 4 (from 4)
|
||||
R4 decl-move a1v 2->0 -> 4 (from 4)
|
||||
R7 block @1371 -> 4 (from 4)
|
||||
s4: verdict NO-MATCH start 9 best 4 compiles 126 path R12 width a1v s32->u16 @1365
|
||||
s7: verdict NO-MATCH start 9 best 4 compiles 158 path R12 width a1v s32->u16 @1365
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R12 width a1v s32->u16 @1365 -> 4 [COUNT] (from 9)
|
||||
R12 width a1v s32->u8 @1365 -> 4 [COUNT] (from 9)
|
||||
R12 width param_2 s32->u16 @1367 -> 4 [COUNT] (from 9)
|
||||
R12 width param_2 s32->u8 @1367 -> 4 [COUNT] (from 9)
|
||||
R7 block @1369 -> 4 [COUNT] (from 4)
|
||||
R2 decl-order 1,0 -> 4 [COUNT] (from 4)
|
||||
R4 decl-move a0v 1->0 -> 4 [COUNT] (from 4)
|
||||
R7 do-while @1369 -> 4 [COUNT] (from 4)
|
||||
R7 block @1370 -> 4 [COUNT] (from 4)
|
||||
R7 do-while @1370 -> 4 [COUNT] (from 4)
|
||||
R4 decl-move a1v 2->0 -> 4 [COUNT] (from 4)
|
||||
R7 block @1371 -> 4 [COUNT] (from 4)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 17 best 17 compiles 819 path
|
||||
g5: verdict NO-MATCH start 17 best 17 compiles 2353 path
|
||||
s1: verdict NO-MATCH start 17 best 17 compiles 190 path
|
||||
s2: verdict NO-MATCH start 17 best 17 compiles 190 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R8 temp tmp0 @1952 -> 17 (from 17)
|
||||
R7 block @2003 -> 17 (from 17)
|
||||
R10 param-copy arg0 @1949 -> 17 (from 17)
|
||||
R8 base tmp0 @1952 -> 17 (from 17)
|
||||
R7 do-while @2003 -> 17 (from 17)
|
||||
R7 block @1949 -> 17 (from 17)
|
||||
R8 temp tmp0 @1959 -> 17 (from 17)
|
||||
R7 block @1972 -> 17 (from 17)
|
||||
R8 temp tmp0 @2001 -> 17 (from 17)
|
||||
R7 do-while @1972 -> 17 (from 17)
|
||||
R8 temp tmp0 @1999 -> 17 (from 17)
|
||||
R7 block @1960 -> 17 (from 17)
|
||||
s4: verdict NO-MATCH start 17 best 17 compiles 445 path
|
||||
s7: verdict NO-MATCH start 17 best 17 compiles 570 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R8 temp tmp0 @1952 -> 17 [COUNT] (from 17)
|
||||
R7 block @2003 -> 17 [COUNT] (from 17)
|
||||
R10 param-copy arg0 @1949 -> 17 [COUNT] (from 17)
|
||||
R8 base tmp0 @1952 -> 17 [COUNT] (from 17)
|
||||
R7 do-while @2003 -> 17 [COUNT] (from 17)
|
||||
R7 block @1949 -> 17 [COUNT] (from 17)
|
||||
R8 temp tmp0 @1959 -> 17 [COUNT] (from 17)
|
||||
R7 block @1972 -> 17 [COUNT] (from 17)
|
||||
R8 temp tmp0 @2001 -> 17 [COUNT] (from 17)
|
||||
R7 do-while @1972 -> 17 [COUNT] (from 17)
|
||||
R8 temp tmp0 @1999 -> 17 [COUNT] (from 17)
|
||||
R7 block @1960 -> 17 [COUNT] (from 17)
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
void func_8015FBE0(s32 *param_1)
|
||||
{
|
||||
|
||||
extern u8 D_800B9A17;
|
||||
if (param_1[0x61] < 0) {
|
||||
((void (**)())D_80192AC8)[*(u16 *)param_1]();
|
||||
((void (*)(s32 *, s16))func_80147078)(param_1, 0);
|
||||
((void (*)(s32 *))func_80159B70)(param_1);
|
||||
} else {
|
||||
D_80078EC1 = 0;
|
||||
((void (*)(s32 *, s32))func_80154150)(param_1, 0x20);
|
||||
((void (*)(s32 *, s32))func_80154A74)(param_1, 0x18);
|
||||
((void (*)(s32, s32 *, s32, s32, s32, s32, s32))func_80146A6C)(0x16, param_1, 0, 0, 0, 0, 0);
|
||||
func_80147324(0x44F);
|
||||
((void (*)(s32 *))func_801553A8)(param_1);
|
||||
((void (*)(s32 *))func_801553C0)(param_1);
|
||||
D_801270C0 = 2;
|
||||
D_800B9A17 = 0;
|
||||
((void (*)(s32 *))func_80146CA0)(param_1);
|
||||
}
|
||||
}
|
||||
@@ -3,16 +3,18 @@ g4s: verdict NO-MATCH start 3 best 3 compiles 526 path
|
||||
g5: verdict NO-MATCH start 3 best 3 compiles 1018 path
|
||||
s1: verdict NO-MATCH start 3 best 3 compiles 156 path
|
||||
s2: verdict NO-MATCH start 3 best 3 compiles 156 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R8 temp tmp0 @2807 -> 3 (from 3)
|
||||
R7 block @2811 -> 3 (from 3)
|
||||
R7 do-while @2811 -> 3 (from 3)
|
||||
R7 block @2809 -> 3 (from 3)
|
||||
R7 do-while @2809 -> 3 (from 3)
|
||||
R7 block @2812 -> 3 (from 3)
|
||||
R7 do-while @2812 -> 3 (from 3)
|
||||
R7 block @2808 -> 3 (from 3)
|
||||
R7 do-while @2808 -> 3 (from 3)
|
||||
R7 block @2807 -> 3 (from 3)
|
||||
R7 do-while @2807 -> 3 (from 3)
|
||||
R7 block @2813 -> 3 (from 3)
|
||||
s4: verdict NO-MATCH start 3 best 3 compiles 440 path
|
||||
s7: verdict NO-MATCH start 3 best 3 compiles 560 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R8 temp tmp0 @2807 -> 3 [COUNT] (from 3)
|
||||
R7 block @2811 -> 3 [COUNT] (from 3)
|
||||
R7 do-while @2811 -> 3 [COUNT] (from 3)
|
||||
R7 block @2809 -> 3 [COUNT] (from 3)
|
||||
R7 do-while @2809 -> 3 [COUNT] (from 3)
|
||||
R7 block @2812 -> 3 [COUNT] (from 3)
|
||||
R7 do-while @2812 -> 3 [COUNT] (from 3)
|
||||
R7 block @2808 -> 3 [COUNT] (from 3)
|
||||
R7 do-while @2808 -> 3 [COUNT] (from 3)
|
||||
R7 block @2807 -> 3 [COUNT] (from 3)
|
||||
R7 do-while @2807 -> 3 [COUNT] (from 3)
|
||||
R7 block @2813 -> 3 [COUNT] (from 3)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 15 best 14 compiles 809 path R9 swap-stmts @3639
|
||||
g5: verdict NO-MATCH start 15 best 13 compiles 2070 path R9 swap-stmts @3639 + R7 do-while @3648
|
||||
s1: verdict NO-MATCH start 15 best 14 compiles 187 path R9 swap-stmts @3639
|
||||
s2: verdict NO-MATCH start 15 best 14 compiles 187 path R9 swap-stmts @3639
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R9 swap-stmts @3639 -> 14 (from 15)
|
||||
R12 width a2 s32->u16 @3607 -> 14 (from 14)
|
||||
R6 inline p @3640 -> 14 (from 14)
|
||||
R8 hoist tmp0 @3624 -> 14 (from 14)
|
||||
R7 block @3628 -> 14 (from 14)
|
||||
R10 param-copy param_1 @3608 -> 14 (from 14)
|
||||
R12 width a2 s32->s16 @3607 -> 14 (from 14)
|
||||
R8 hoist tmp0 @3623 -> 14 (from 14)
|
||||
R7 block @3629 -> 14 (from 14)
|
||||
R7 block @3624 -> 14 (from 14)
|
||||
R8 hoist tmp0 @3634 -> 14 (from 14)
|
||||
R9 swap-stmts @3622 -> 14 (from 14)
|
||||
s4: verdict NO-MATCH start 15 best 14 compiles 436 path R9 swap-stmts @3639
|
||||
s7: verdict NO-MATCH start 15 best 14 compiles 556 path R9 swap-stmts @3639
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R9 swap-stmts @3639 -> 14 [COUNT] (from 15)
|
||||
R12 width a2 s32->u16 @3607 -> 14 [COUNT] (from 14)
|
||||
R6 inline p @3640 -> 14 [COUNT] (from 14)
|
||||
R8 hoist tmp0 @3624 -> 14 [COUNT] (from 14)
|
||||
R7 block @3628 -> 14 [COUNT] (from 14)
|
||||
R10 param-copy param_1 @3608 -> 14 [COUNT] (from 14)
|
||||
R12 width a2 s32->s16 @3607 -> 14 [COUNT] (from 14)
|
||||
R8 hoist tmp0 @3623 -> 14 [COUNT] (from 14)
|
||||
R7 block @3629 -> 14 [COUNT] (from 14)
|
||||
R7 block @3624 -> 14 [COUNT] (from 14)
|
||||
R8 hoist tmp0 @3634 -> 14 [COUNT] (from 14)
|
||||
R9 swap-stmts @3622 -> 14 [COUNT] (from 14)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 10 best 8 compiles 813 path R9 swap-stmts @3863 + R9
|
||||
g5: verdict NO-MATCH start 10 best 8 compiles 2253 path R9 swap-stmts @3863 + R9 swap-stmts @3864 + R9 swap-stmts @3865
|
||||
s1: verdict NO-MATCH start 10 best 10 compiles 188 path
|
||||
s2: verdict NO-MATCH start 10 best 10 compiles 188 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R12 width uVar2 u32->u16 @3832 -> 10 (from 10)
|
||||
R6 inline t @3851 -> 10 (from 10)
|
||||
R8 hoist tmp0 @3848 -> 10 (from 10)
|
||||
R7 block @3848 -> 10 (from 10)
|
||||
R12 width uVar2 u32->s16 @3832 -> 10 (from 10)
|
||||
R6 inline t @3840 -> 10 (from 10)
|
||||
R9 swap-stmts @3846 -> 10 (from 10)
|
||||
R6 inline t @3862 -> 10 (from 10)
|
||||
R8 hoist tmp0 @3847 -> 10 (from 10)
|
||||
R7 block @3847 -> 10 (from 10)
|
||||
R7 block @3846 -> 10 (from 10)
|
||||
R8 hoist tmp0 @3858 -> 10 (from 10)
|
||||
s4: verdict NO-MATCH start 10 best 10 compiles 434 path
|
||||
s7: verdict NO-MATCH start 10 best 9 compiles 558 path R7 block @3848 + R9 swap-stmts @3863
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R9 swap-stmts @3863 -> 9 [COUNT] (from 10)
|
||||
R12 width uVar2 u32->u16 @3832 -> 9 [COUNT] (from 9)
|
||||
R6 inline t @3851 -> 9 [COUNT] (from 9)
|
||||
R8 hoist tmp0 @3847 -> 9 [COUNT] (from 9)
|
||||
R7 unwrap @3848 -> 9 [COUNT] (from 9)
|
||||
R12 width uVar2 u32->s16 @3832 -> 9 [COUNT] (from 9)
|
||||
R6 inline t @3840 -> 9 [COUNT] (from 9)
|
||||
R7 block @3847 -> 9 [COUNT] (from 9)
|
||||
R9 swap-stmts @3846 -> 9 [COUNT] (from 9)
|
||||
R6 inline t @3862 -> 9 [COUNT] (from 9)
|
||||
R6 inline item @3864 -> 9 [COUNT] (from 9)
|
||||
R7 block @3852 -> 9 [COUNT] (from 9)
|
||||
|
||||
@@ -0,0 +1,14 @@
|
||||
void func_801627E8(void)
|
||||
{
|
||||
|
||||
extern s32 D_8011F750; /* canonical: engine_core.h `extern s32 D_8011F750;` (read here as a byte) */
|
||||
extern void (*D_80192FD0[])(void); /* word-stride table of dispatch fn pointers */
|
||||
u8 *p = (u8 *)&D_8011F750;
|
||||
s32 idx;
|
||||
|
||||
idx = *p;
|
||||
if (idx != 0) {
|
||||
idx = idx - 1;
|
||||
D_80192FD0[idx]();
|
||||
}
|
||||
}
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 7 best 4 compiles 181 path R7 do-while @3940
|
||||
g5: verdict NO-MATCH start 7 best 4 compiles 263 path R7 do-while @3940
|
||||
s1: verdict NO-MATCH start 7 best 4 compiles 60 path R7 do-while @3940
|
||||
s2: verdict NO-MATCH start 7 best 4 compiles 60 path R7 do-while @3940
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 do-while @3940 -> 4 (from 7)
|
||||
R6 inline p @3937 -> 4 (from 4)
|
||||
R3 init-split p -> 4 (from 4)
|
||||
R4 decl-move p 1->0 -> 4 (from 4)
|
||||
R12 width idx s32->s16 @3938 -> 4 (from 4)
|
||||
R7 block @3942 -> 4 (from 4)
|
||||
R4 decl-move p 1->2 -> 4 (from 4)
|
||||
R7 do-while @3942 -> 4 (from 4)
|
||||
R7 block @3943 -> 4 (from 4)
|
||||
R7 do-while @3943 -> 4 (from 4)
|
||||
R7 do-while @3939 -> 4 (from 7)
|
||||
R12 width idx s32->u16 @3938 -> 6 (from 4)
|
||||
s4: verdict NO-MATCH start 7 best 3 compiles 104 path R3 init-split p + R18 bystander @3941->3939
|
||||
s7: verdict NO-MATCH start 7 best 3 compiles 130 path R3 init-split p + R18 bystander @3941->3939
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R18 bystander @3941->3939 -> 3 [COUNT] (from 7)
|
||||
R7 block @3939 -> 3 [COUNT] (from 3)
|
||||
R4 decl-move p 1->0 -> 3 [COUNT] (from 3)
|
||||
R12 width idx s32->s16 @3938 -> 3 [COUNT] (from 3)
|
||||
R7 do-while @3939 -> 3 [COUNT] (from 3)
|
||||
R4 decl-move p 1->2 -> 3 [COUNT] (from 3)
|
||||
R7 block @3940 -> 3 [COUNT] (from 3)
|
||||
R7 do-while @3940 -> 3 [COUNT] (from 3)
|
||||
R7 block @3943 -> 3 [COUNT] (from 3)
|
||||
R7 do-while @3943 -> 3 [COUNT] (from 3)
|
||||
R7 block @3944 -> 3 [COUNT] (from 3)
|
||||
R7 do-while @3944 -> 3 [COUNT] (from 3)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 29 best 8 compiles 345 path R6 inline iVar2 @4550 + R
|
||||
g5: verdict NO-MATCH start 29 best 8 compiles 629 path R6 inline iVar2 @4549 + R7 do-while @4553
|
||||
s1: verdict NO-MATCH start 29 best 8 compiles 127 path R6 inline iVar2 @4549 + R7 do-while @4553
|
||||
s2: verdict NO-MATCH start 29 best 8 compiles 128 path R6 inline iVar2 @4549 + R7 do-while @4553
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 do-while @4553 -> 8 (from 13)
|
||||
R6 inline iVar2 @4549 -> 13 (from 29)
|
||||
R6 inline a0v @4552 -> 13 (from 13)
|
||||
R8 hoist tmp0 @4554 -> 13 (from 13)
|
||||
R7 block @4547 -> 13 (from 13)
|
||||
R4 decl-move puVar1 0->1 -> 13 (from 13)
|
||||
R10 param-copy param_1 @4546 -> 13 (from 13)
|
||||
R4 decl-move puVar1 0->2 -> 13 (from 13)
|
||||
R7 block @4553 -> 13 (from 13)
|
||||
R12 width iVar2 s32->u16 @4544 -> 13 (from 13)
|
||||
R9 swap-stmts @4556 -> 13 (from 13)
|
||||
R12 width iVar2 s32->s16 @4544 -> 13 (from 13)
|
||||
s4: verdict NO-MATCH start 29 best 8 compiles 217 path R6 inline iVar2 @4549 + R7 do-while @4553
|
||||
s7: verdict NO-MATCH start 29 best 8 compiles 279 path R6 inline iVar2 @4549 + R7 do-while @4553
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 do-while @4553 -> 8 [COUNT] (from 13)
|
||||
R6 inline a0v @4552 -> 8 [COUNT] (from 8)
|
||||
R8 hoist tmp0 @4554 -> 8 [COUNT] (from 8)
|
||||
R7 block @4547 -> 8 [COUNT] (from 8)
|
||||
R4 decl-move puVar1 0->1 -> 8 [COUNT] (from 8)
|
||||
R10 param-copy param_1 @4546 -> 8 [COUNT] (from 8)
|
||||
R4 decl-move puVar1 0->2 -> 8 [COUNT] (from 8)
|
||||
R9 swap-stmts @4556 -> 8 [COUNT] (from 8)
|
||||
R12 width iVar2 s32->u16 @4544 -> 8 [COUNT] (from 8)
|
||||
R7 block @4554 -> 8 [COUNT] (from 8)
|
||||
R12 width iVar2 s32->s16 @4544 -> 8 [COUNT] (from 8)
|
||||
R12 width iVar2 s32->u8 @4544 -> 8 [COUNT] (from 8)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 41 best 26 compiles 815 path R7 do-while @4931 + R9 s
|
||||
g5: verdict NO-MATCH start 41 best 16 compiles 2332 path R7 do-while @4930 + R12 width iVar3 int->u16 @4881 + R9 swap-stmts @4921 + R12 width w3 int->s16 @4883
|
||||
s1: verdict NO-MATCH start 41 best 24 compiles 188 path R7 do-while @4930 + R12 width iVar3 int->s16 @4881
|
||||
s2: verdict NO-MATCH start 41 best 24 compiles 188 path R7 do-while @4930 + R12 width iVar3 int->s16 @4881
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R12 width iVar3 int->s16 @4881 -> 24 (from 34)
|
||||
R12 width iVar3 int->u16 @4881 -> 26 (from 34)
|
||||
R7 do-while @4943 -> 29 (from 38)
|
||||
R7 do-while @4921 -> 31 (from 38)
|
||||
R6 inline uVar7 @4897 -> 33 (from 34)
|
||||
R12 width iVar3 int->u16 @4881 -> 33 (from 38)
|
||||
R12 width iVar3 int->s16 @4881 -> 33 (from 38)
|
||||
R7 do-while @4930 -> 34 (from 41)
|
||||
R12 width sVar10 short->s32 @4884 -> 34 (from 34)
|
||||
R14 param-width param_1 s32->s16 @4866 -> 34 (from 34)
|
||||
R7 block @4889 -> 34 (from 34)
|
||||
R9 swap-stmts @4889 -> 34 (from 34)
|
||||
s4: verdict NO-MATCH start 41 best 18 compiles 438 path R7 do-while @4930 + R12 width iVar3 int->u16 @4881 + R9 swap-stmts @4921
|
||||
s7: verdict NO-MATCH start 41 best 18 compiles 562 path R7 do-while @4930 + R12 width iVar3 int->u16 @4881 + R9 swap-stmts @4921
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R9 swap-stmts @4921 -> 18 [COUNT] (from 26)
|
||||
R12 width w3 int->s16 @4883 -> 22 [COUNT] (from 24)
|
||||
R9 swap-stmts @4921 -> 22 [COUNT] (from 24)
|
||||
R12 width w3 int->s16 @4883 -> 22 [COUNT] (from 24)
|
||||
R12 width w3 int->s16 @4883 -> 22 [COUNT] (from 24)
|
||||
R9 swap-stmts @4921 -> 22 [COUNT] (from 24)
|
||||
R12 width iVar3 int->s16 @4881 -> 24 [COUNT] (from 34)
|
||||
R7 do-while @4921 -> 24 [COUNT] (from 39)
|
||||
R7 do-while @4929 -> 24 [COUNT] (from 39)
|
||||
R12 width sVar10 short->s32 @4884 -> 24 [COUNT] (from 24)
|
||||
R14 param-width param_1 s32->s16 @4866 -> 24 [COUNT] (from 24)
|
||||
R8 hoist tmp0 @4920 -> 24 [COUNT] (from 24)
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
s32 func_80166F58(s32 param_1, s32 param_2, s32 param_3, s32 param_4)
|
||||
{
|
||||
/* [T51] scoped in from file scope: a file-scope decl of these symbols constrains every
|
||||
LATER function in this TU, which blocks a byte-true decl of a different type.
|
||||
Declaration-only move (cookbook §103); the whole-binary byte-gate is the arbiter. */
|
||||
extern s32 D_8011D030;
|
||||
extern unsigned char D_801EDD28[];
|
||||
|
||||
int p2;
|
||||
int p3;
|
||||
unsigned short *puVar1;
|
||||
short iVar2;
|
||||
int eq;
|
||||
|
||||
iVar2 = 0;
|
||||
puVar1 = ((unsigned short *)&D_8011D030);
|
||||
param_2 = ((short)param_2);
|
||||
p2 = param_2;
|
||||
param_3 = ((short)param_3);
|
||||
p3 = param_3;
|
||||
eq = (p2 == p3);
|
||||
do {
|
||||
if ((puVar1 != ((unsigned short *)param_1)) &&
|
||||
((unsigned int)*puVar1 == p2 || (unsigned int)*puVar1 == p3) &&
|
||||
(!eq ||
|
||||
*(int *)(puVar1 + 0x16) == *(int *)(((unsigned short *)param_1) + 0x16))) {
|
||||
((void(*)(unsigned short *))func_80146C3C)(puVar1);
|
||||
}
|
||||
iVar2 = iVar2 + 1;
|
||||
puVar1 = puVar1 + 0x2c;
|
||||
} while (iVar2 < 0x1e);
|
||||
((void(*)(void *, int))func_80016714)(&D_801EDD28[((short)param_4) * 0xc4], 0xc4);
|
||||
}
|
||||
@@ -3,16 +3,18 @@ g4s: verdict NO-MATCH start 4 best 4 compiles 487 path
|
||||
g5: verdict NO-MATCH start 4 best 4 compiles 888 path
|
||||
s1: verdict NO-MATCH start 4 best 4 compiles 164 path
|
||||
s2: verdict NO-MATCH start 4 best 4 compiles 164 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 block @5132 -> 4 (from 4)
|
||||
R2 decl-order 1,0 -> 4 (from 4)
|
||||
R9 swap-stmts @5133 -> 4 (from 4)
|
||||
R7 block @5133 -> 4 (from 4)
|
||||
R14 param-width param_2 s32->s16 @5116 -> 4 (from 4)
|
||||
R14 param-width param_2 s32->u16 @5116 -> 4 (from 4)
|
||||
R7 block @5134 -> 4 (from 4)
|
||||
R9 swap-stmts @5144 -> 4 (from 4)
|
||||
R14 param-width param_3 s32->s16 @5116 -> 4 (from 4)
|
||||
R14 param-width param_3 s32->u16 @5116 -> 4 (from 4)
|
||||
R7 block @5136 -> 4 (from 4)
|
||||
R14 param-width param_4 s32->s16 @5116 -> 4 (from 4)
|
||||
s4: verdict NO-MATCH start 4 best 4 compiles 310 path
|
||||
s7: verdict NO-MATCH start 4 best 4 compiles 282 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 block @5132 -> 4 [COUNT] (from 4)
|
||||
R2 decl-order 1,0 -> 4 [COUNT] (from 4)
|
||||
R9 swap-stmts @5133 -> 4 [COUNT] (from 4)
|
||||
R18 bystander @5133->5136 -> 4 [COUNT] (from 4)
|
||||
R7 block @5133 -> 4 [COUNT] (from 4)
|
||||
R18 bystander @5134->5132 -> 4 [COUNT] (from 4)
|
||||
R7 block @5134 -> 4 [COUNT] (from 4)
|
||||
R9 swap-stmts @5144 -> 4 [COUNT] (from 4)
|
||||
R7 block @5136 -> 4 [COUNT] (from 4)
|
||||
R7 block @5142 -> 4 [COUNT] (from 4)
|
||||
R7 do-while @5142 -> 4 [COUNT] (from 4)
|
||||
R7 block @5144 -> 4 [COUNT] (from 4)
|
||||
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 45 best 31 compiles 810 path R6 inline vc @5284 + R12
|
||||
g5: verdict NO-MATCH start 45 best 31 compiles 2306 path R7 do-while @5236 + R12 width cxv s32->s16 @5193 + R6 inline vc @5283
|
||||
s1: verdict NO-MATCH start 45 best 43 compiles 190 path R7 do-while @5233 + R6 inline gA @5257
|
||||
s2: verdict NO-MATCH start 45 best 43 compiles 190 path R7 do-while @5233 + R6 inline gA @5257
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R6 inline gA @5257 -> 43 (from 44)
|
||||
R7 do-while @5233 -> 44 (from 45)
|
||||
R6 inline gA @5257 -> 44 (from 45)
|
||||
R10 param-copy arg0 @5200 -> 44 (from 44)
|
||||
R2 decl-order 1,0 -> 44 (from 44)
|
||||
R4 decl-move gA 16->0 -> 44 (from 44)
|
||||
R6 inline vb @5214 -> 44 (from 44)
|
||||
R8 temp tmp0 @5202 -> 44 (from 44)
|
||||
R7 block @5234 -> 44 (from 44)
|
||||
R10 param-copy arg1 @5200 -> 44 (from 44)
|
||||
R4 decl-move gA 16->1 -> 44 (from 44)
|
||||
R8 base tmp0 @5202 -> 44 (from 44)
|
||||
s4: verdict NO-MATCH start 45 best 43 compiles 441 path R7 do-while @5233 + R6 inline gA @5257
|
||||
s7: verdict NO-MATCH start 45 best 43 compiles 560 path R7 do-while @5233 + R6 inline gA @5257
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R6 inline gA @5257 -> 43 [COUNT] (from 44)
|
||||
R6 inline gA @5260 -> 43 [COUNT] (from 44)
|
||||
R7 block @5241 -> 43 [COUNT] (from 43)
|
||||
R10 param-copy arg0 @5200 -> 43 [COUNT] (from 43)
|
||||
R2 decl-order 1,0 -> 43 [COUNT] (from 43)
|
||||
R4 decl-move gA 16->0 -> 43 [COUNT] (from 43)
|
||||
R6 inline vb @5214 -> 43 [COUNT] (from 43)
|
||||
R8 temp tmp0 @5202 -> 43 [COUNT] (from 43)
|
||||
R10 param-copy arg1 @5200 -> 43 [COUNT] (from 43)
|
||||
R4 decl-move gA 16->1 -> 43 [COUNT] (from 43)
|
||||
R8 base tmp0 @5202 -> 43 [COUNT] (from 43)
|
||||
R7 block @5206 -> 43 [COUNT] (from 43)
|
||||
|
||||
@@ -0,0 +1,60 @@
|
||||
void func_8016B234(s32 param_1) {
|
||||
|
||||
extern u8 D_800AF648;
|
||||
extern u8 D_80193590;
|
||||
short input[3];
|
||||
Prim_B234 prim;
|
||||
struct { s16 xy[2]; s32 sp1c; s32 flag; } out;
|
||||
void *dp;
|
||||
u32 uVar1;
|
||||
s16 iVar2;
|
||||
s32 X, Y0, Y1, base, ni;
|
||||
s32 sy;
|
||||
s16 xtmp;
|
||||
s32 sxy;
|
||||
|
||||
dp = &D_800AF648;
|
||||
func_8004914C(dp);
|
||||
func_800491AC(dp);
|
||||
input[0] = *(u16 *)(param_1 + 6);
|
||||
input[1] = *(u16 *)(param_1 + 0xA);
|
||||
input[2] = *(u16 *)(param_1 + 0xE);
|
||||
RotTransPers((s32)input, (s32)out.xy, &out.sp1c, &out.flag);
|
||||
if ((out.flag & 0xffffefff) == 0) {
|
||||
sxy = *(s32 *)out.xy;
|
||||
prim.a04 = 0x10;
|
||||
X = *(u16 *)(param_1 + 0x2a) + sxy;
|
||||
sy = (u16)out.xy[1];
|
||||
prim.ax = prim.cx = X;
|
||||
prim.bx = prim.dx = X + 8;
|
||||
Y0 = sy - *(u16 *)(param_1 + 0x26);
|
||||
prim.ay = prim.by = Y0;
|
||||
sxy = *(u16 *)(param_1 + 0x26);
|
||||
prim.v0 = prim.v1 = 0x1d0;
|
||||
prim.v2 = prim.v3 = 0x1d8;
|
||||
sxy = sy + sxy;
|
||||
prim.cy = prim.dy = sxy;
|
||||
prim.r = prim.g = prim.b = *(u8 *)(param_1 + 0x24);
|
||||
prim.code = (&D_80193590)[*(s32 *)(param_1 + 0x2c)];
|
||||
if (*(s16 *)(param_1 + 0x26) < 5) {
|
||||
prim.tag = 0;
|
||||
} else {
|
||||
prim.tag = 0x50000000;
|
||||
}
|
||||
uVar1 = *(u16 *)(param_1 + 0x30);
|
||||
iVar2 = 0;
|
||||
if (0 < *(s16 *)(param_1 + 0x28) + 1) {
|
||||
do {
|
||||
base = ((uVar1 + 1) & 0xf) << 3;
|
||||
prim.u0 = prim.u2 = base + 0x620;
|
||||
prim.u1 = prim.u3 = base + 0x628;
|
||||
func_80016ED4(&prim);
|
||||
uVar1 = (s32)(uVar1 << 0x10) >> 0x14;
|
||||
iVar2 = iVar2 + 1;
|
||||
xtmp = prim.ax;
|
||||
prim.cx = prim.ax = xtmp - 8;
|
||||
prim.bx = prim.dx = xtmp;
|
||||
} while ((s16)iVar2 < *(s16 *)(param_1 + 0x28) + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 13 best 5 compiles 813 path R9 swap-stmts @2063 + R6
|
||||
g5: verdict NO-MATCH start 13 best 3 compiles 2304 path R12 width sxy s32->s16 @2042 + R12 width X s32->u16 @2039
|
||||
s1: verdict NO-MATCH start 13 best 5 compiles 186 path R12 width sxy s32->s16 @2042 + R6 inline sxy @2052
|
||||
s2: verdict NO-MATCH start 13 best 5 compiles 186 path R12 width sxy s32->s16 @2042 + R6 inline sxy @2052
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R6 inline sxy @2052 -> 5 (from 7)
|
||||
R12 width sxy s32->s16 @2042 -> 7 (from 13)
|
||||
R8 temp tmp0 @2066 -> 7 (from 7)
|
||||
R7 block @2045 -> 7 (from 7)
|
||||
R10 param-copy param_1 @2043 -> 7 (from 7)
|
||||
R2 decl-order 1,0 -> 7 (from 7)
|
||||
R6 inline Y0 @2058 -> 7 (from 7)
|
||||
R8 base tmp0 @2066 -> 7 (from 7)
|
||||
R5 swap + @2063 -> 7 (from 7)
|
||||
R6 inline sxy @2063 -> 7 (from 7)
|
||||
R8 temp tmp0 @2065 -> 7 (from 7)
|
||||
R7 block @2046 -> 7 (from 7)
|
||||
s4: verdict NO-MATCH start 13 best 3 compiles 435 path R12 width sxy s32->s16 @2042 + R6 inline sxy @2052 + R8 hoist tmp0 @2053
|
||||
s7: verdict NO-MATCH start 13 best 3 compiles 554 path R12 width sxy s32->s16 @2042 + R6 inline sxy @2052 + R8 hoist tmp0 @2053
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R8 hoist tmp0 @2053 -> 3 [REG] (from 5)
|
||||
R6 inline sxy @2052 -> 5 [COUNT] (from 7)
|
||||
R9 swap-stmts @2052 -> 5 [COUNT] (from 7)
|
||||
R6 inline Y0 @2057 -> 5 [COUNT] (from 5)
|
||||
R8 temp tmp0 @2049 -> 5 [COUNT] (from 5)
|
||||
R7 block @2045 -> 5 [COUNT] (from 5)
|
||||
R10 param-copy param_1 @2043 -> 5 [COUNT] (from 5)
|
||||
R2 decl-order 1,0 -> 5 [COUNT] (from 5)
|
||||
R12 width sxy s16->u16 @2042 -> 5 [COUNT] (from 5)
|
||||
R8 base tmp0 @2049 -> 5 [COUNT] (from 5)
|
||||
R5 swap + @2062 -> 5 [COUNT] (from 5)
|
||||
R6 inline sxy @2062 -> 5 [COUNT] (from 5)
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
s32 func_8016C49C(s32 param_1_arg) {
|
||||
extern s32 VectorNormalSS(void *, void *);
|
||||
extern void func_8001CD9C(s32, void *);
|
||||
extern void func_8016CF04(s32, s32);
|
||||
extern u8 D_801EE120[];
|
||||
extern u8 D_801EE1E0;
|
||||
|
||||
u16 *param_1 = ((u16 *)param_1_arg);
|
||||
int iVar5;
|
||||
int iVar6;
|
||||
u16 sv[4];
|
||||
s32 mat[8];
|
||||
short sVar1;
|
||||
|
||||
iVar5 = *(int *)(param_1 + 0x18);
|
||||
iVar6 = *(int *)(param_1 + 0x1a);
|
||||
param_1[0x14] = *(u16 *)(iVar5 + 0x36);
|
||||
if ((*(u32 *)(param_1 + 0x16) & 0x8000) == 0) {
|
||||
short iVar4 = 0;
|
||||
u16 *psVar3 = (u16 *)&D_8011D030;
|
||||
do {
|
||||
if (psVar3 != param_1 && *psVar3 == 0x30) {
|
||||
((void(*)(void *))func_80146C3C)(psVar3);
|
||||
}
|
||||
iVar4 = iVar4 + 1;
|
||||
psVar3 = psVar3 + 0x2c;
|
||||
} while (iVar4 < 0x1e);
|
||||
D_801EE120[1] = 0xff;
|
||||
D_801EE120[2] = 0x10;
|
||||
D_801EE120[0] = 0x10;
|
||||
D_801EE120[6] = 0;
|
||||
D_801EE120[5] = 0;
|
||||
D_801EE120[4] = 0;
|
||||
((void(*)(void *, s32))func_800233CC)(D_801EE120, 10);
|
||||
sv[0] = *(u16 *)(iVar5 + 6) - *(u16 *)(iVar6 + 6);
|
||||
{
|
||||
int t = *(u16 *)(iVar6 + 0xa) + 0x28;
|
||||
sv[1] = *(u16 *)(iVar5 + 0xa) - t;
|
||||
}
|
||||
sv[2] = *(u16 *)(iVar5 + 0xe) - *(u16 *)(iVar6 + 0xe);
|
||||
VectorNormalSS(sv, sv);
|
||||
param_1[3] = *(u16 *)(iVar5 + 6) + ((s16)sv[0] >> 9);
|
||||
param_1[5] = *(u16 *)(iVar5 + 0xa) + (((s16)sv[1] >> 9) - 0x28);
|
||||
param_1[7] = *(u16 *)(iVar5 + 0xe) + ((s16)sv[2] >> 9);
|
||||
((void(*)(void *))func_800D23D0)(sv);
|
||||
sv[0] = 0;
|
||||
((void(*)(void *, void *))RotMatrixYXZ)(sv, param_1 + 0x1c);
|
||||
((void(*)(void *, s32))func_80016714)(&D_801EE1E0, 0x620);
|
||||
((s32(*)(s32, void *, s32, s32, s32, s32, s32))func_80146A6C)(0x32, param_1, 0, 0, 0, 0, *(int *)(param_1 + 0x18));
|
||||
sVar1 = 5;
|
||||
} else {
|
||||
int iVar5b = ((s32(*)())func_801465C0)();
|
||||
u32 uVar2;
|
||||
if (iVar5b == 0) {
|
||||
return;
|
||||
}
|
||||
func_8001CD9C(iVar5b, D_801EE120);
|
||||
*(u32 *)(iVar5b + 4) |= 0x50000000;
|
||||
uVar2 = ((int(*)())rand)();
|
||||
sv[0] = (uVar2 & 0x7f) * 8 - 0x80;
|
||||
sv[1] = ((uVar2 & 0x7f00) >> 4) - 0x400;
|
||||
sv[2] = 0;
|
||||
((void(*)(void *, void *))RotMatrixYXZ)(sv, mat);
|
||||
((void(*)(void *, void *))func_80048EAC)(param_1 + 0x1c, mat);
|
||||
sv[1] = 0;
|
||||
sv[0] = 0;
|
||||
sv[2] = 0xb;
|
||||
((void(*)(void *, void *, void *))ApplyMatrixSV)(mat, sv, sv);
|
||||
param_1[9] = sv[0];
|
||||
param_1[0xb] = sv[1];
|
||||
param_1[0xd] = sv[2];
|
||||
*(int *)(param_1 + 0x10) = iVar5b;
|
||||
*(int *)(param_1 + 0xe) = 8;
|
||||
func_8016CF04((s32)param_1, 0);
|
||||
*(int *)(param_1 + 0x16) = 0;
|
||||
sVar1 = param_1[1] + 1;
|
||||
}
|
||||
do { param_1[1] = sVar1; } while (0);
|
||||
}
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 34 best 6 compiles 806 path R7 do-while @2744
|
||||
g5: verdict NO-MATCH start 34 best 2 compiles 2307 path R7 do-while @2714
|
||||
s1: verdict NO-MATCH start 34 best 6 compiles 193 path R7 do-while @2746
|
||||
s2: verdict NO-MATCH start 34 best 6 compiles 193 path R7 do-while @2746
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 do-while @2746 -> 6 (from 34)
|
||||
R7 block @2741 -> 6 (from 6)
|
||||
R3 init-split param_1 -> 6 (from 6)
|
||||
R8 temp tmp0 @2741 -> 6 (from 6)
|
||||
R5 swap + @2741 -> 6 (from 6)
|
||||
R12 width sVar1 short->s32 @2712 -> 6 (from 6)
|
||||
R4 decl-move param_1 2->0 -> 6 (from 6)
|
||||
R8 base tmp0 @2741 -> 6 (from 6)
|
||||
R5 swap + @2742 -> 6 (from 6)
|
||||
R12 width sVar1 short->u16 @2712 -> 6 (from 6)
|
||||
R4 decl-move param_1 2->1 -> 6 (from 6)
|
||||
R7 block @2742 -> 6 (from 6)
|
||||
s4: verdict NO-MATCH start 34 best 6 compiles 446 path R7 do-while @2746
|
||||
s7: verdict NO-MATCH start 34 best 1 compiles 568 path R14 param-width param_1_arg s32->u16 @2700 + R15 sink @2777 (sVar1)
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R15 sink @2777 (sVar1) -> 1 [OTHER] (from 34)
|
||||
R3 init-split param_1 -> 1 [OTHER] (from 1)
|
||||
R4 decl-move param_1 2->0 -> 1 [OTHER] (from 1)
|
||||
R7 block @2713 -> 1 [OTHER] (from 1)
|
||||
R8 temp tmp0 @2713 -> 1 [OTHER] (from 1)
|
||||
R9 swap-stmts @2713 -> 1 [OTHER] (from 1)
|
||||
R4 decl-move param_1 2->1 -> 1 [OTHER] (from 1)
|
||||
R5 swap + @2740 -> 1 [OTHER] (from 1)
|
||||
R8 base tmp0 @2713 -> 1 [OTHER] (from 1)
|
||||
R9 swap-stmts @2714 -> 1 [OTHER] (from 1)
|
||||
R4 decl-move param_1 2->3 -> 1 [OTHER] (from 1)
|
||||
R5 swap + @2741 -> 1 [OTHER] (from 1)
|
||||
|
||||
@@ -0,0 +1,163 @@
|
||||
# func_8016C49C (ov_SC04_011_jr_8016AB6C.c:2700) — CLOSED, score 0
|
||||
|
||||
Final: **score 0 (MATCH, 172/172 instructions, byte-identical)** from a seed of 34.
|
||||
Body: `PACK/body.c` — **one line changed** from `body_free.c`.
|
||||
|
||||
## (a) The residual in one sentence
|
||||
|
||||
Every one of the 34 differing words was a *pure two-way rename of two callee-saved registers*
|
||||
(`s2->s1 x22, s1->s2 x11`, class MIXED, `mine 172 ins, target 172`, not one instruction added,
|
||||
removed or moved): my build put `param_1` in `$s2` and the loop counter / `iVar5b` in `$s1`, the
|
||||
target the other way round — i.e. `global.c` visited the two allocnos in the opposite order.
|
||||
|
||||
## (b) The pass and the decision, with `file:line`
|
||||
|
||||
Pass: **`global_alloc`** (`tools/reference/gcc-2.7.2/global.c`), fed by **`life_analysis`**
|
||||
(`flow.c`). Both read from the pinned cc1's own dumps (`-dl -dg`), not from theory.
|
||||
|
||||
1. `global.c:546` — `qsort (allocno_order, max_allocno, sizeof (int), allocno_compare);`
|
||||
2. `global.c:587` — `allocno_compare`'s priority is
|
||||
`(floor_log2 (n_refs) * n_refs / live_length) * 10000 * size`.
|
||||
3. `global.c:904` — `find_reg` then colours in that order; MIPS declares no `REG_ALLOC_ORDER`, so
|
||||
it is plain first-fit over the regnos, and *whoever is compared first takes `$s1`*.
|
||||
|
||||
The `.greg` dump prints exactly that order on its `;; N regs to allocate:` line, so the reading is
|
||||
checkable against a known-true case. Lever-free seed (`dumps_base`, my extended `alloc_table` view):
|
||||
|
||||
```
|
||||
;; 8 regs to allocate: 81 76 80 73 74 140 75 84 <- the qsort order
|
||||
r81 psVar3 refs=11 live=14 pri=23571 -> $s0
|
||||
r76 sVar1 refs=3 live=4 pri=7500 -> $v0
|
||||
r80 iVar4 refs=5 live=15 pri=6666 -> $s1 <<< wins the race
|
||||
r73 param_1 refs=23 live=141 pri=6524 -> $s2 <<< loses it by 142/10000
|
||||
r74 iVar5 refs=8 live=67 pri=3582 -> $s3
|
||||
r140 iVar5b refs=6 live=43 pri=2790 -> $s1 (no conflict with r80)
|
||||
r75 iVar6 refs=4 live=41 pri=1951 -> $s4
|
||||
r84 (0x30) refs=3 live=26 pri=1153 -> $s5
|
||||
```
|
||||
|
||||
Reproducing those eight priorities by hand from the formula gives the printed order exactly, so the
|
||||
instrument is sound. **The whole 34-point residual is one `qsort` comparison, decided by 142 units
|
||||
out of 6666 — 2%.**
|
||||
|
||||
The move therefore has to raise `reg_n_refs[73]` from 23 to 24 (`pri` 6524 -> 6808 > 6666) without
|
||||
emitting an instruction. That is possible because **`reg_n_refs` is a LOOP-WEIGHTED count, and it is
|
||||
computed before `combine` and before `sched1`** (`toplev.c:2983` `flow_analysis`, then `:3004`
|
||||
`combine_instructions`, `:3033` `schedule_insns`, `:3052` `local_alloc`, `:3080` `global_alloc`):
|
||||
|
||||
* `flow.c:434` — `find_basic_blocks` starts its scan at **`depth = 1`**;
|
||||
* `flow.c:440-443` — `depth++` on `NOTE_INSN_LOOP_BEG`, `depth--` on `NOTE_INSN_LOOP_END`;
|
||||
`:456`/`:471` store it per block, `:1385` reloads it per block for the backward scan;
|
||||
* `flow.c:2067` (`mark_set_regs`) and `flow.c:2501`/`:2711` (`mark_used_regs`) —
|
||||
`reg_n_refs[regno] += loop_depth;`.
|
||||
|
||||
So **a reference that sits between a `NOTE_INSN_LOOP_BEG`/`_END` pair is counted twice.** The whole
|
||||
seed table is arithmetic on that rule, which is how I checked it before spending a compile: r84 (the
|
||||
loop-invariant `0x30`) has 1 def outside + 1 use inside = `1 + 2*1 = 3` refs; r81 (`psVar3`) has 1 def
|
||||
outside + 5 occurrences inside = `1 + 2*5 = 11`; r80 (`iVar4`) `1 + 2*2 = 5`; r73 (`param_1`)
|
||||
`21 + 2*1 = 23`. All four match the dump.
|
||||
|
||||
## (c) The move that closed it — one line
|
||||
|
||||
* Wrap the function's **last statement** in the canonical statement-macro idiom:
|
||||
`param_1[1] = sVar1;` -> **`do { param_1[1] = sVar1; } while (0);`** (line 2777).
|
||||
|
||||
`do {} while (0)` emits a `NOTE_INSN_LOOP_BEG`/`_END` pair around that store, so the `param_1`
|
||||
reference in it is weighted 2 instead of 1; `reg_n_refs[73]` 23 -> 24, `pri` 6524 -> 6808, the
|
||||
`qsort` order becomes `81 76 73 80 74 140 75 84`, `find_reg` hands `param_1` `$s1` and the counter
|
||||
`$s2`, and every one of the 34 words falls into place. Proven on bytes:
|
||||
|
||||
```
|
||||
win: order [81, 76, 73, 80, 74, 140, 75, 84]
|
||||
r73 refs=24 live=141 pri=6808 <- +1 ref, nothing else in the table moved
|
||||
r80 refs=5 live=15 pri=6666
|
||||
-> score 0 (OTHER; mine 172 ins, target 172) — MATCH
|
||||
```
|
||||
|
||||
**The control that proves it is the notes and not the scope:** the *plain block* at the same site,
|
||||
`{ param_1[1] = sVar1; }`, leaves the table untouched (`r73` refs=23, order `81 76 80 73 …`) and
|
||||
scores **34** — the seed's score, to the point. A brace block emits no loop notes; only `do/while`
|
||||
does.
|
||||
|
||||
**Why the tail position is free.** `do/while` notes are also a `sched1` region barrier, which is why
|
||||
R18's docstring records that R7 "always costs one displaced insn". Measured here across all 47
|
||||
`do-while` sites in this body: 22 of them change the instruction *count*, and of the 25 that keep 172
|
||||
instructions only the **last statement of the function** scores 0 — the next best terminal-ish sites
|
||||
(`@2714`, `@2748`, `@2763`) score 2 with class ORDER, i.e. the barrier displaced a pair. At the final
|
||||
statement there is nothing left to schedule across, so the barrier is free and only the ref weight
|
||||
survives. **Position, not site count, is the discriminator.**
|
||||
|
||||
## (d) Generator proposal — one sentence
|
||||
|
||||
**R19 `loop_note_weights`: when the residual is a pure callee-saved rename (equal instruction counts,
|
||||
`pairs` only) and the `.greg` priority table shows the two contending allocnos adjacent in
|
||||
`allocno_order`, wrap in `do { … } while (0);` the LAST statement of the enclosing block that
|
||||
references the under-weighted pseudo — one candidate, not 47 — because the loop notes double that
|
||||
reference's `loop_depth` weight in `reg_n_refs` (`flow.c:2067/2501`) and flip `allocno_compare`
|
||||
(`global.c:587`) at zero instruction cost only in tail position.**
|
||||
|
||||
Concretely the generator is R7's do-while spelling made *directed* by a computed quantity that no
|
||||
current generator uses: read `;; N regs to allocate:` + `Register N used K times across M insns` from
|
||||
a single `-dl -dg` compile, recompute `floor_log2(K)*K/M*10000`, and emit candidates only where the
|
||||
smallest `+1 ref` (or `+1 live`) flips a specific adjacent pair — then rank those by *tail distance*
|
||||
(last statement of a block first), the inverse of the engine's current NEEDED-site distance ranking.
|
||||
The same table also says when to stop: if no single `+1 ref` / `+1 live_length` closes the gap, the
|
||||
class is not reachable by a note move at all. It is new against R15 `sink_merges` (a `block_alloc`
|
||||
quantity move), R16 `constant_holders` (deletes a quantity), R17 `constant_run_splits` (a
|
||||
`find_free_reg` live-range overlap) and R18 `bystander_moves` (`reg_live_length` via statement
|
||||
distance): those all move `local-alloc`'s block quantities, this one moves `global.c`'s *priority*,
|
||||
and it is the only one that changes a ref *weight* rather than a ref *position*.
|
||||
|
||||
## (e) What did NOT work, with byte evidence
|
||||
|
||||
| Try | Score | Why |
|
||||
|---|---|---|
|
||||
| R15 `sink_merges` — `param_1[1] = sVar1` sunk into both arms (the tool's own candidate, byte-for-byte) | **40**, `mine 173` | duplicates the `sh` at the merge; the target has one. The `-> 1` in `history.txt` is **not reproducible from the lever-free seed** — I ran `dl.sink_merges` itself and scored its exact text. |
|
||||
| Plain block `{ param_1[1] = sVar1; }` @2777 | **34** | the control above: no loop notes, table unchanged. |
|
||||
| Swap the two loop-init declarations (`psVar3` before `iVar4`) | 35 | moves the *counter's* birth the wrong way: its `live` 15 -> 14 (pri 6666 -> 7142), `psVar3` 14 -> 15. Widens the gap. |
|
||||
| `int iVar4` instead of `short` | 41, `mine 169` | drops the `sll/sra` truncation; three instructions gone. |
|
||||
| Both loop locals declared at function top (`D`) | 34 | RTL identical; table identical. |
|
||||
| R3 init-split of `param_1` (`u16 *param_1; param_1 = …;`) | 34 | ditto. |
|
||||
| Parameter re-typed `u16 *param_1_arg` | 34 | ditto — and **unbankable anyway**, see below. |
|
||||
| Nested `if`s instead of `&&` in the loop | 34 | ditto. |
|
||||
| R14 `param-width param_1_arg s32->u16` (the move `history.txt` credits for `best 1`) | not pursued | **cannot be banked.** The bank is body-only, and this TU's definition is not the only declaration: `extern s32 func_8016C49C(s32 param_1_arg);` appears in 20+ sibling TUs (`ov_SC04_011_jr_8017AE2C.c:1846`, `…_jr_80171B4C.c:1863`, `ov_SC03_099_*`, `ov_SC06_008_*`, …) and the body is also instantiated through `src/shared/ov/func_8016C49C__0db10db0.h`. `delever.protos_outside_definition` only inspects the *current* TU, so R14 still offers this candidate here even though the width change would have to leave the definition. Not needed — the answer above needs no signature change. |
|
||||
|
||||
## (f) Where the method fell short — and the fix, with evidence
|
||||
|
||||
**The winning candidate was generated by the existing tooling in every one of the six runs and thrown
|
||||
away unscored, every time.**
|
||||
|
||||
`delever.recipe_candidates` builds 439 candidates for this body and sorts them by *distance to the
|
||||
nearest NEEDED site* (`delever.py:2520-2529`); the only NEEDED site is the pin on the declaration at
|
||||
line 2707, and the answer is at line 2777 — the farthest statement in the body. Measured:
|
||||
|
||||
```
|
||||
total candidates: 439
|
||||
rank of "do-while @2777": 438 (cap = 48)
|
||||
```
|
||||
|
||||
Dead last of 439, cut by `--cap 48` in g3, g5, s1, s2, s4 and s7 — together ~4,300 compiles that
|
||||
could never have reached a one-move answer. Two concrete fixes:
|
||||
|
||||
1. **The NEEDED-site distance heuristic is exactly backwards for the register-order class.** A pin on
|
||||
a *declaration* says which VALUE is mis-coloured; it says nothing about which STATEMENT to weight,
|
||||
and for a `global.c` priority flip the cheapest statement is the one furthest from the declaration
|
||||
(the tail, where the `sched1` barrier is free). For residual class `MIXED`/`pairs`-only, rank by
|
||||
*tail position*, or simply never let `cap` drop the last statement of a block.
|
||||
2. **The engine never reads the allocator's own answer.** One `-dl -dg` compile (0.3 s, the same cost
|
||||
as one scored candidate) prints `;; N regs to allocate:` and the refs/live of every pseudo; from
|
||||
those eight numbers the required move — "+1 ref on r73" — is arithmetic, and the search space
|
||||
collapses from 439 blind candidates to one. I spent ~15 compiles total, and the reading came
|
||||
first. `tools/alloc_table.py` already parses these dumps but prints only the callee-saved holders
|
||||
and drops the `;; N regs to allocate:` order line, which is the single most informative line in
|
||||
the `.greg` dump; it also missed 7 of the 8 allocnos here because its `Register N in M.` regex does
|
||||
not match this dump's `;; Register dispositions:` block. Both are small fixes and would make the
|
||||
instrument usable as the first step of every `regalloc-order` body.
|
||||
|
||||
**Claims proved on bytes:** the priority table and its arithmetic (reproduced by hand and matched
|
||||
against the `.greg` order line, twice — seed and winner); the `+1 ref` from the loop notes; the
|
||||
plain-block control; the free-only-in-tail-position result (47 measured sites); the R15 refutation.
|
||||
**Claims NOT proved:** that `sched.c:2058-2074` is the specific barrier making the non-tail
|
||||
do-while sites cost 2 (I measured the cost, I did not read the `.sched` dump for it); and that the
|
||||
original source used a statement macro here — that is only the natural reading of why a
|
||||
`do { … } while (0)` sits around this one store.
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 55 best 21 compiles 820 path R7 do-while @2922 + R6 i
|
||||
g5: verdict NO-MATCH start 55 best 11 compiles 2341 path R7 do-while @2924 + R6 inline uc @2980 + R12 width iVar3 int->u16 @2869 + R12 width w3 int->s16 @2870
|
||||
s1: verdict NO-MATCH start 55 best 15 compiles 190 path R9 swap-stmts @2922 + R12 width iVar3 int->s16 @2869
|
||||
s2: verdict NO-MATCH start 55 best 29 compiles 191 path R6 inline uc @2980 + R7 do-while @2934
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 do-while @2934 -> 29 (from 30)
|
||||
R6 inline uc @2980 -> 30 (from 55)
|
||||
R7 block @2934 -> 30 (from 30)
|
||||
R9 swap-stmts @2896 -> 30 (from 30)
|
||||
R7 block @2896 -> 30 (from 30)
|
||||
R9 swap-stmts @2898 -> 30 (from 30)
|
||||
R12 width count short->s32 @2872 -> 30 (from 30)
|
||||
R9 swap-stmts @2919 -> 30 (from 30)
|
||||
R12 width count short->u16 @2872 -> 30 (from 30)
|
||||
R7 block @2898 -> 30 (from 30)
|
||||
R9 swap-stmts @2897 -> 30 (from 30)
|
||||
R9 swap-stmts @2895 -> 30 (from 30)
|
||||
s4: verdict NO-MATCH start 55 best 14 compiles 445 path R9 swap-stmts @2922 + R12 width iVar3 int->u16 @2869 + R7 do-while @2918
|
||||
s7: verdict NO-MATCH start 55 best 14 compiles 569 path R9 swap-stmts @2922 + R12 width iVar3 int->u16 @2869 + R7 do-while @2918
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 do-while @2918 -> 14 [COUNT] (from 18)
|
||||
R12 width w3 int->s16 @2870 -> 16 [COUNT] (from 18)
|
||||
R12 width iVar3 int->u16 @2869 -> 18 [COUNT] (from 48)
|
||||
R7 block @2918 -> 18 [COUNT] (from 18)
|
||||
R6 inline uc @2980 -> 18 [COUNT] (from 18)
|
||||
R9 swap-stmts @2897 -> 18 [COUNT] (from 18)
|
||||
R7 block @2897 -> 18 [COUNT] (from 18)
|
||||
R12 width count short->s32 @2872 -> 18 [COUNT] (from 18)
|
||||
R9 swap-stmts @2895 -> 18 [COUNT] (from 18)
|
||||
R12 width count short->u16 @2872 -> 18 [COUNT] (from 18)
|
||||
R18 bystander @2875->2878 -> 18 [COUNT] (from 18)
|
||||
R7 block @2931 -> 18 [COUNT] (from 18)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 58 best 31 compiles 811 path R9 swap-stmts @2830 + R7
|
||||
g5: verdict NO-MATCH start 41 best 26 compiles 2294 path R9 swap-stmts @2857 + R8 hoist tmp0 @2848 + R12 width sum s32->u8 @2824 + R9 swap-stmts @2831
|
||||
s1: verdict NO-MATCH start 41 best 39 compiles 188 path R8 cse tmp0 @2833
|
||||
s2: verdict NO-MATCH start 41 best 39 compiles 188 path R8 cse tmp0 @2833
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R8 cse tmp0 @2833 -> 39 (from 41)
|
||||
R6 inline sv @2845 -> 39 (from 39)
|
||||
R5 swap + @2854 -> 39 (from 39)
|
||||
R9 swap-stmts @2840 -> 39 (from 39)
|
||||
R2 decl-order 1,0 -> 39 (from 39)
|
||||
R4 decl-move a0v 19->1 -> 39 (from 39)
|
||||
R7 block @2840 -> 39 (from 39)
|
||||
R4 decl-move a0v 19->2 -> 39 (from 39)
|
||||
R8 hoist tmp1 @2849 -> 39 (from 39)
|
||||
R7 do-while @2840 -> 39 (from 39)
|
||||
R4 decl-move a0v 19->3 -> 39 (from 39)
|
||||
R12 width q s16->u16 @2821 -> 39 (from 39)
|
||||
s4: verdict NO-MATCH start 41 best 39 compiles 439 path R8 cse tmp0 @2833
|
||||
s7: verdict NO-MATCH start 41 best 39 compiles 556 path R8 cse tmp0 @2833
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R8 cse tmp0 @2833 -> 39 [COUNT] (from 41)
|
||||
R6 inline sv @2845 -> 39 [COUNT] (from 39)
|
||||
R5 swap + @2854 -> 39 [COUNT] (from 39)
|
||||
R9 swap-stmts @2840 -> 39 [COUNT] (from 39)
|
||||
R2 decl-order 1,0 -> 39 [COUNT] (from 39)
|
||||
R4 decl-move a0v 19->1 -> 39 [COUNT] (from 39)
|
||||
R7 block @2840 -> 39 [COUNT] (from 39)
|
||||
R4 decl-move a0v 19->2 -> 39 [COUNT] (from 39)
|
||||
R8 hoist tmp1 @2849 -> 39 [COUNT] (from 39)
|
||||
R18 bystander @2853->2849 -> 39 [COUNT] (from 39)
|
||||
R7 do-while @2840 -> 39 [COUNT] (from 39)
|
||||
R4 decl-move a0v 19->3 -> 39 [COUNT] (from 39)
|
||||
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 90 best 74 compiles 801 path R7 do-while @3329 + R9 s
|
||||
g5: verdict NO-MATCH start 90 best 32 compiles 2294 path R7 do-while @3328 + R12 width amp s32->s16 @3318 + R9 swap-stmts @3342 + R12 width chg s32->u16 @3316 + R7 unwrap @3328
|
||||
s1: verdict NO-MATCH start 90 best 65 compiles 188 path R12 width amp s32->s16 @3318 + R7 do-while @3328
|
||||
s2: verdict NO-MATCH start 90 best 65 compiles 188 path R12 width amp s32->s16 @3318 + R7 do-while @3328
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 do-while @3328 -> 65 (from 79)
|
||||
R7 do-while @3324 -> 71 (from 79)
|
||||
R7 do-while @3328 -> 76 (from 90)
|
||||
R12 width pv s32->u16 @3320 -> 76 (from 76)
|
||||
R7 block @3324 -> 76 (from 76)
|
||||
R12 width pv s32->s16 @3320 -> 76 (from 76)
|
||||
R10 param-copy param_1 @3323 -> 76 (from 76)
|
||||
R6 inline fb @3416 -> 76 (from 76)
|
||||
R8 hoist tmp0 @3325 -> 76 (from 76)
|
||||
R7 block @3326 -> 76 (from 76)
|
||||
R5 swap + @3325 -> 76 (from 76)
|
||||
R9 swap-stmts @3363 -> 76 (from 76)
|
||||
s4: verdict NO-MATCH start 90 best 63 compiles 437 path R12 width amp s32->s16 @3318 + R7 do-while @3328 + R9 swap-stmts @3342
|
||||
s7: verdict NO-MATCH start 90 best 56 compiles 559 path R12 width amp s32->s16 @3318 + R10 param-alias pv->param_1 @3326 + R12 width chg s32->u16 @3316
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R12 width chg s32->u16 @3316 -> 56 [COUNT] (from 76)
|
||||
R12 width chg s32->s16 @3316 -> 56 [COUNT] (from 76)
|
||||
R12 width chg s32->u8 @3316 -> 56 [COUNT] (from 76)
|
||||
R9 swap-stmts @3342 -> 63 [COUNT] (from 65)
|
||||
R7 do-while @3328 -> 65 [COUNT] (from 79)
|
||||
R7 block @3326 -> 65 [COUNT] (from 65)
|
||||
R12 width tgt u16->s16 @3319 -> 65 [COUNT] (from 65)
|
||||
R10 param-copy param_1 @3323 -> 65 [COUNT] (from 65)
|
||||
R6 inline fb @3416 -> 65 [COUNT] (from 65)
|
||||
R8 hoist tmp0 @3325 -> 65 [COUNT] (from 65)
|
||||
R5 swap + @3325 -> 65 [COUNT] (from 65)
|
||||
R12 width pv s32->u16 @3320 -> 65 [COUNT] (from 65)
|
||||
|
||||
@@ -3,16 +3,18 @@ g2: verdict NO-MATCH start 135 best 112 compiles 819 path R7 do-while @3674 + R8
|
||||
g5: verdict NO-MATCH start 135 best 106 compiles 2326 path R6 inline yt @3670 + R7 do-while @3673 + R12 width x s32->u8 @3635 + R6 inline yt @3689 + R9 swap-stmts @3681
|
||||
s1: verdict NO-MATCH start 135 best 119 compiles 189 path R6 inline yt @3670 + R9 swap-stmts @3673
|
||||
s2: verdict NO-MATCH start 135 best 119 compiles 188 path R6 inline yt @3670 + R16 const-holder cc1=0x74808080 x2
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R16 const-holder cc1=0x74808080 x2 -> 119 (from 130)
|
||||
R9 swap-stmts @3673 -> 119 (from 130)
|
||||
R7 do-while @3671 -> 122 (from 133)
|
||||
R7 do-while @3670 -> 123 (from 133)
|
||||
R6 inline yt @3670 -> 124 (from 129)
|
||||
R12 width y s32->s16 @3636 -> 127 (from 129)
|
||||
R9 swap-stmts @3674 -> 127 (from 129)
|
||||
R12 width y s32->u8 @3636 -> 127 (from 129)
|
||||
R12 width x s32->u8 @3635 -> 129 (from 135)
|
||||
R16 const-holder ca=0x3000000 x2 -> 129 (from 129)
|
||||
R8 hoist tmp0 @3683 -> 129 (from 129)
|
||||
R7 block @3670 -> 129 (from 129)
|
||||
s4: verdict NO-MATCH start 135 best 114 compiles 439 path R6 inline yt @3670 + R9 swap-stmts @3673 + R12 width x s32->u8 @3635
|
||||
s7: verdict NO-MATCH start 135 best 114 compiles 561 path R6 inline yt @3670 + R9 swap-stmts @3673 + R12 width x s32->u8 @3635
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R12 width x s32->u8 @3635 -> 114 [COUNT] (from 119)
|
||||
R12 width x s32->u8 @3635 -> 114 [COUNT] (from 119)
|
||||
R12 width n u32->u16 @3650 -> 116 [COUNT] (from 119)
|
||||
R18 bystander @3673->3679 -> 117 [COUNT] (from 122)
|
||||
R18 bystander @3674->3679 -> 117 [COUNT] (from 122)
|
||||
R18 bystander @3673->3676 -> 118 [COUNT] (from 122)
|
||||
R18 bystander @3673->3677 -> 118 [COUNT] (from 122)
|
||||
R16 const-holder cc1=0x74808080 x2 -> 118 [COUNT] (from 122)
|
||||
R18 bystander @3673->3678 -> 118 [COUNT] (from 122)
|
||||
R9 swap-stmts @3674 -> 118 [COUNT] (from 122)
|
||||
R18 bystander @3674->3677 -> 118 [COUNT] (from 122)
|
||||
R18 bystander @3674->3678 -> 118 [COUNT] (from 122)
|
||||
|
||||
@@ -0,0 +1,11 @@
|
||||
int func_80178970(void)
|
||||
{
|
||||
int r;
|
||||
int v;
|
||||
|
||||
v = ((s32 (*)(void))func_801789AC)();
|
||||
r = 0;
|
||||
if (v != 0)
|
||||
r = D_801F1638 == 0;
|
||||
return r;
|
||||
}
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 6 best 3 compiles 54 path R6 inline r @3896
|
||||
g5: verdict NO-MATCH start 6 best 3 compiles 203 path R6 inline r @3895
|
||||
s1: verdict NO-MATCH start 6 best 3 compiles 56 path R6 inline r @3895
|
||||
s2: verdict NO-MATCH start 6 best 3 compiles 56 path R6 inline r @3895
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R6 inline r @3895 -> 3 (from 6)
|
||||
R12 width v int->u16 @3890 -> 3 (from 3)
|
||||
R6 inline v @3892 -> 3 (from 3)
|
||||
R7 block @3892 -> 3 (from 3)
|
||||
R9 swap-stmts @3892 -> 3 (from 3)
|
||||
R4 decl-move r 0->1 -> 3 (from 3)
|
||||
R12 width v int->s16 @3890 -> 3 (from 3)
|
||||
R7 do-while @3892 -> 3 (from 3)
|
||||
R12 width v int->u8 @3890 -> 3 (from 3)
|
||||
R7 block @3893 -> 3 (from 3)
|
||||
R12 width r int->u16 @3889 -> 3 (from 3)
|
||||
R7 do-while @3893 -> 3 (from 3)
|
||||
s4: verdict NO-MATCH start 6 best 3 compiles 84 path R6 inline r @3895
|
||||
s7: verdict NO-MATCH start 6 best 3 compiles 101 path R6 inline r @3895
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R6 inline r @3895 -> 3 [COUNT] (from 6)
|
||||
R12 width v int->u16 @3890 -> 3 [MIXED] (from 3)
|
||||
R6 inline v @3892 -> 3 [COUNT] (from 3)
|
||||
R7 block @3892 -> 3 [COUNT] (from 3)
|
||||
R9 swap-stmts @3892 -> 3 [COUNT] (from 3)
|
||||
R4 decl-move r 0->1 -> 3 [COUNT] (from 3)
|
||||
R12 width v int->s16 @3890 -> 3 [MIXED] (from 3)
|
||||
R7 do-while @3892 -> 3 [COUNT] (from 3)
|
||||
R12 width v int->u8 @3890 -> 3 [MIXED] (from 3)
|
||||
R7 block @3893 -> 3 [COUNT] (from 3)
|
||||
R12 width r int->u16 @3889 -> 3 [COUNT] (from 3)
|
||||
R7 do-while @3893 -> 3 [COUNT] (from 3)
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
int func_8017A3D8(void)
|
||||
{
|
||||
int a;
|
||||
|
||||
switch (D_801EEC94) {
|
||||
case 0:
|
||||
func_800D0CA0(1);
|
||||
D_801EEC94 = D_801EEC94 + 1;
|
||||
return 0;
|
||||
case 100:
|
||||
a = D_801EEC90;
|
||||
if (a != -1) {
|
||||
return func_8001AAA0() != 0;
|
||||
}
|
||||
return func_800D0CE0() == 1;
|
||||
default:
|
||||
D_801EEC94 = D_801EEC94 + 1;
|
||||
if (D_801EEC94 < 0x1E) {
|
||||
return 0;
|
||||
}
|
||||
D_801EEC94 = 100;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
@@ -3,16 +3,18 @@ g4s: verdict NO-MATCH start 3 best 3 compiles 101 path
|
||||
g5: verdict NO-MATCH start 3 best 3 compiles 135 path
|
||||
s1: verdict NO-MATCH start 3 best 3 compiles 52 path
|
||||
s2: verdict NO-MATCH start 3 best 3 compiles 52 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R6 inline a @3508 -> 3 (from 3)
|
||||
R7 block @3508 -> 3 (from 3)
|
||||
R7 do-while @3508 -> 3 (from 3)
|
||||
R7 block @3503 -> 3 (from 3)
|
||||
R7 block @3502 -> 3 (from 3)
|
||||
R7 do-while @3502 -> 3 (from 3)
|
||||
R7 block @3515 -> 3 (from 3)
|
||||
R7 do-while @3515 -> 3 (from 3)
|
||||
R7 block @3519 -> 3 (from 3)
|
||||
R7 do-while @3519 -> 3 (from 3)
|
||||
R7 block @3503 -> 3 (from 3)
|
||||
R7 block @3502 -> 3 (from 3)
|
||||
s4: verdict NO-MATCH start 3 best 3 compiles 75 path
|
||||
s7: verdict NO-MATCH start 3 best 3 compiles 86 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R6 inline a @3508 -> 3 [REG] (from 3)
|
||||
R7 block @3508 -> 3 [REG] (from 3)
|
||||
R7 do-while @3508 -> 3 [REG] (from 3)
|
||||
R7 block @3503 -> 3 [REG] (from 3)
|
||||
R7 block @3502 -> 3 [REG] (from 3)
|
||||
R7 do-while @3502 -> 3 [REG] (from 3)
|
||||
R7 block @3515 -> 3 [REG] (from 3)
|
||||
R7 do-while @3515 -> 3 [REG] (from 3)
|
||||
R7 block @3519 -> 3 [REG] (from 3)
|
||||
R7 do-while @3519 -> 3 [REG] (from 3)
|
||||
R7 block @3503 -> 3 [REG] (from 3)
|
||||
R7 block @3502 -> 3 [REG] (from 3)
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
s32 func_8017B238(s32 param_1, s32 param_2)
|
||||
{
|
||||
extern void func_8012F214(s32 a0, s32 a1, s32 a2);
|
||||
extern s32 func_8017BE60(void *a0);
|
||||
extern u8 D_80193D6C[];
|
||||
extern s16 D_801EECD4;
|
||||
extern s16 D_801EECCC;
|
||||
extern u8 D_8012694C;
|
||||
|
||||
|
||||
u8 buf[16];
|
||||
|
||||
if (((u32)param_2) >= 0xB) {
|
||||
u8 *src;
|
||||
src = (u8 *)((u32)param_2);
|
||||
*(Blk8_8017B238_8017B238 *)&buf[0] = *(Blk8_8017B238_8017B238 *)src;
|
||||
*(Blk8_8017B238_8017B238 *)&buf[8] = *(Blk8_8017B238_8017B238 *)(src + 8);
|
||||
} else {
|
||||
s32 a1addr = (s32)&D_80193D6C[((u32)param_2) * 0x10];
|
||||
s32 a2addr = (s32)&D_80193D6C[((u32)param_2) * 0x10 + 8];
|
||||
func_8012F214(param_1, a1addr, (s32)&buf[0]);
|
||||
func_8012F214(param_1, a2addr, (s32)&buf[8]);
|
||||
}
|
||||
{
|
||||
s16 *p794 = &D_801EECD4;
|
||||
s16 *p78C = &D_801EECCC;
|
||||
*(Blk8_8017B238_8017B238 *)p794 = *(Blk8_8017B238_8017B238 *)&buf[0];
|
||||
*(Blk8_8017B238_8017B238 *)p78C = *(Blk8_8017B238_8017B238 *)&buf[8];
|
||||
func_8012A018((s32)func_8017BE60, 0);
|
||||
D_8012694C = 0;
|
||||
D_801F1638 = 1;
|
||||
D_801EEC5C = 0;
|
||||
}
|
||||
}
|
||||
@@ -3,16 +3,18 @@ g4s: verdict NO-MATCH start 7 best 7 compiles 791 path
|
||||
g5: verdict NO-MATCH start 7 best 7 compiles 1317 path
|
||||
s1: verdict NO-MATCH start 7 best 7 compiles 189 path
|
||||
s2: verdict NO-MATCH start 7 best 7 compiles 189 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 block @2776 -> 7 (from 7)
|
||||
R10 param-copy param_1 @2773 -> 7 (from 7)
|
||||
R7 do-while @2776 -> 7 (from 7)
|
||||
R6 inline p794 @2786 -> 7 (from 7)
|
||||
R8 base tmp0 @2778 -> 7 (from 7)
|
||||
R7 block @2777 -> 7 (from 7)
|
||||
R10 param-alias src->param_2 @2776 -> 7 (from 7)
|
||||
R6 inline p78C @2787 -> 7 (from 7)
|
||||
R7 do-while @2777 -> 7 (from 7)
|
||||
R7 block @2778 -> 7 (from 7)
|
||||
R7 do-while @2778 -> 7 (from 7)
|
||||
R7 block @2782 -> 7 (from 7)
|
||||
s4: verdict NO-MATCH start 7 best 7 compiles 438 path
|
||||
s7: verdict NO-MATCH start 7 best 7 compiles 559 path
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 block @2776 -> 7 [COUNT] (from 7)
|
||||
R10 param-copy param_1 @2773 -> 7 [COUNT] (from 7)
|
||||
R7 do-while @2776 -> 7 [COUNT] (from 7)
|
||||
R6 inline p794 @2786 -> 7 [COUNT] (from 7)
|
||||
R8 base tmp0 @2778 -> 7 [COUNT] (from 7)
|
||||
R7 block @2777 -> 7 [COUNT] (from 7)
|
||||
R10 param-alias src->param_2 @2776 -> 7 [COUNT] (from 7)
|
||||
R6 inline p78C @2787 -> 7 [COUNT] (from 7)
|
||||
R7 do-while @2777 -> 7 [COUNT] (from 7)
|
||||
R7 block @2778 -> 7 [COUNT] (from 7)
|
||||
R7 do-while @2778 -> 7 [COUNT] (from 7)
|
||||
R7 block @2782 -> 7 [COUNT] (from 7)
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
s32 func_8017B614(s32 param_1, s32 param_2)
|
||||
{
|
||||
extern void func_8012F214(s32 a0, s32 a1, s32 a2);
|
||||
extern void func_80129CF8(void);
|
||||
extern s32 func_8017BE60(void *a0);
|
||||
extern u8 D_80193D6C[];
|
||||
extern s16 D_801EECD4;
|
||||
extern s16 D_801EECD6;
|
||||
extern s16 D_801EECD8;
|
||||
extern s16 D_801EECCC;
|
||||
extern s16 D_801EECCE;
|
||||
extern s16 D_801EECD0;
|
||||
extern u8 D_8012694C;
|
||||
extern s32 D_80126998;
|
||||
extern s32 D_80126984;
|
||||
extern s32 D_80126988;
|
||||
extern s32 D_8012698C;
|
||||
|
||||
u8 buf[16];
|
||||
|
||||
if (((u32)param_2) >= 0xB) {
|
||||
u8 *src;
|
||||
src = (u8 *)((u32)param_2);
|
||||
*(Blk8_8017B614 *)&buf[0] = *(Blk8_8017B614 *)src;
|
||||
*(Blk8_8017B614 *)&buf[8] = *(Blk8_8017B614 *)(src + 8);
|
||||
} else {
|
||||
s32 a1addr = (s32)&D_80193D6C[((u32)param_2) * 0x10];
|
||||
s32 a2addr = (s32)&D_80193D6C[((u32)param_2) * 0x10 + 8];
|
||||
func_8012F214(param_1, a1addr, (s32)&buf[0]);
|
||||
func_8012F214(param_1, a2addr, (s32)&buf[8]);
|
||||
}
|
||||
{
|
||||
s16 *p794 = &D_801EECD4;
|
||||
s16 *p78C = &D_801EECCC;
|
||||
*(Blk8_8017B614 *)p794 = *(Blk8_8017B614 *)&buf[0];
|
||||
*(Blk8_8017B614 *)p78C = *(Blk8_8017B614 *)&buf[8];
|
||||
((void(*)(s32, s32))func_8012A018)((s32)func_8017BE60, 0);
|
||||
{
|
||||
s32 v794, v796, v798, v78C, v78E, v790;
|
||||
D_8012694C = 0;
|
||||
v794 = *p794;
|
||||
v796 = D_801EECD6;
|
||||
v798 = D_801EECD8;
|
||||
v78C = *p78C;
|
||||
v78E = D_801EECCE;
|
||||
v790 = D_801EECD0;
|
||||
D_801F1638 = 1;
|
||||
D_801EEC5C = 0x1E;
|
||||
D_80126990 = v794;
|
||||
D_80126994 = v796;
|
||||
D_80126998 = v798;
|
||||
D_80126984 = v78C;
|
||||
D_80126988 = v78E;
|
||||
D_8012698C = v790;
|
||||
}
|
||||
func_80129CF8();
|
||||
}
|
||||
}
|
||||
@@ -2,16 +2,18 @@ g3: verdict NO-MATCH start 13 best 7 compiles 814 path R7 do-while @2936 + R7 do
|
||||
g5: verdict NO-MATCH start 13 best 7 compiles 2196 path R7 do-while @2947
|
||||
s1: verdict NO-MATCH start 13 best 13 compiles 188 path
|
||||
s2: verdict NO-MATCH start 13 best 13 compiles 188 path
|
||||
best-scoring single candidates of the last trace (move -> score):
|
||||
R7 block @2944 -> 13 (from 13)
|
||||
R10 param-copy param_1 @2919 -> 13 (from 13)
|
||||
R6 inline v790 @2945 -> 13 (from 13)
|
||||
R7 block @2936 -> 13 (from 13)
|
||||
R9 swap-stmts @2945 -> 13 (from 13)
|
||||
R10 param-alias src->param_2 @2922 -> 13 (from 13)
|
||||
R7 do-while @2936 -> 13 (from 13)
|
||||
R7 block @2935 -> 13 (from 13)
|
||||
R9 swap-stmts @2939 -> 13 (from 13)
|
||||
R7 block @2945 -> 13 (from 13)
|
||||
R9 swap-stmts @2946 -> 13 (from 13)
|
||||
R8 base tmp0 @2924 -> 13 (from 13)
|
||||
s4: verdict NO-MATCH start 13 best 13 compiles 439 path
|
||||
s7: verdict NO-MATCH start 13 best 7 compiles 561 path R7 do-while @2936 + R7 block @2944 + R7 do-while @2946
|
||||
best-scoring single candidates of the last trace (move -> score [residual class]):
|
||||
R7 do-while @2946 -> 7 [COUNT] (from 13)
|
||||
R7 block @2944 -> 13 [COUNT] (from 13)
|
||||
R10 param-copy param_1 @2919 -> 13 [COUNT] (from 13)
|
||||
R6 inline v790 @2945 -> 13 [COUNT] (from 13)
|
||||
R18 bystander @2939->2942 -> 13 [COUNT] (from 13)
|
||||
R18 bystander @2939->2943 -> 13 [COUNT] (from 13)
|
||||
R7 block @2936 -> 13 [COUNT] (from 13)
|
||||
R9 swap-stmts @2945 -> 13 [COUNT] (from 13)
|
||||
R10 param-alias src->param_2 @2922 -> 13 [COUNT] (from 13)
|
||||
R18 bystander @2939->2944 -> 13 [COUNT] (from 13)
|
||||
R7 do-while @2936 -> 13 [COUNT] (from 13)
|
||||
R18 bystander @2939->2945 -> 13 [COUNT] (from 13)
|
||||
|
||||
@@ -72,16 +72,16 @@
|
||||
"binaries": 218,
|
||||
"classes": {
|
||||
"A": {
|
||||
"bodies": 7331,
|
||||
"distinct_bodies": 971,
|
||||
"bodies": 7204,
|
||||
"distinct_bodies": 970,
|
||||
"file_scope": 0,
|
||||
"in_bodies": 16989,
|
||||
"in_bodies": 16862,
|
||||
"kinds": {
|
||||
"pin": 16989
|
||||
"pin": 16862
|
||||
},
|
||||
"marked": 16989,
|
||||
"sites": 16989,
|
||||
"tus": 2488,
|
||||
"marked": 16862,
|
||||
"sites": 16862,
|
||||
"tus": 2487,
|
||||
"unmarked": 0
|
||||
},
|
||||
"B": {
|
||||
@@ -207,9 +207,9 @@
|
||||
"coverage": {
|
||||
"asm": {
|
||||
"comment_dead": 6792,
|
||||
"live": 39047,
|
||||
"live": 38920,
|
||||
"macro_block": 194,
|
||||
"raw": 46033
|
||||
"raw": 45906
|
||||
},
|
||||
"attribute": {
|
||||
"comment_dead": 0,
|
||||
@@ -225,19 +225,19 @@
|
||||
},
|
||||
"register": {
|
||||
"comment_dead": 8587,
|
||||
"live": 17039,
|
||||
"live": 16912,
|
||||
"macro_block": 18,
|
||||
"raw": 25644
|
||||
"raw": 25517
|
||||
},
|
||||
"volatile": {
|
||||
"comment_dead": 2607,
|
||||
"live": 2021,
|
||||
"comment_dead": 2480,
|
||||
"live": 1894,
|
||||
"macro_block": 82,
|
||||
"raw": 4710
|
||||
"raw": 4456
|
||||
}
|
||||
},
|
||||
"coverage_ok": true,
|
||||
"elapsed_s": 24.2,
|
||||
"elapsed_s": 26.2,
|
||||
"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": "724c68859",
|
||||
"head": "bb0e95c7c",
|
||||
"headers": 3181,
|
||||
"levers_AB": {
|
||||
"asm": 12151,
|
||||
"bodies": 9005,
|
||||
"distinct_bodies": 1280,
|
||||
"marked": 29140,
|
||||
"pins": 16989,
|
||||
"sites": 29140,
|
||||
"bodies": 8878,
|
||||
"distinct_bodies": 1279,
|
||||
"marked": 29013,
|
||||
"pins": 16862,
|
||||
"sites": 29013,
|
||||
"unmarked": 0,
|
||||
"what": "register pins + asm statements excluding GTE ops: the classes the phase drives to 0"
|
||||
},
|
||||
@@ -390,7 +390,7 @@
|
||||
},
|
||||
"pins": {
|
||||
"bare_name": 15,
|
||||
"init": 2410,
|
||||
"init": 2283,
|
||||
"registers": {
|
||||
"$0": 773,
|
||||
"$10": 144,
|
||||
@@ -411,7 +411,7 @@
|
||||
"$25": 1,
|
||||
"$29": 13,
|
||||
"$3": 1919,
|
||||
"$4": 2683,
|
||||
"$4": 2556,
|
||||
"$5": 2312,
|
||||
"$6": 470,
|
||||
"$7": 704,
|
||||
@@ -423,30 +423,30 @@
|
||||
"v0": 2,
|
||||
"v1": 3
|
||||
},
|
||||
"sites": 16989,
|
||||
"sites": 16862,
|
||||
"sp": 13,
|
||||
"spelling": {
|
||||
"__asm__": 16911,
|
||||
"__asm__": 16784,
|
||||
"asm": 78
|
||||
},
|
||||
"volatile_qualified": 134,
|
||||
"volatile_qualified": 7,
|
||||
"zero": 773
|
||||
},
|
||||
"src_stamp": "86452185689d0cb7",
|
||||
"src_stamp": "715f57b7c9b0d6a6",
|
||||
"tus": 4121,
|
||||
"unclassified": 0,
|
||||
"union_AD": {
|
||||
"bodies": 12268,
|
||||
"bodies": 12141,
|
||||
"by_kind": {
|
||||
"main": 165,
|
||||
"md": 135,
|
||||
"ov": 11709,
|
||||
"ov": 11583,
|
||||
"resident": 10,
|
||||
"shared": 249
|
||||
"shared": 248
|
||||
},
|
||||
"copies_in_multi": 11002,
|
||||
"distinct_bodies": 1565,
|
||||
"multi_copy_classes": 299
|
||||
"copies_in_multi": 10875,
|
||||
"distinct_bodies": 1564,
|
||||
"multi_copy_classes": 298
|
||||
},
|
||||
"verbatim_excluded": {
|
||||
"functions": 13,
|
||||
|
||||
@@ -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 46033 = live 39047 + macro-block 194 + comment/dead 6792
|
||||
coverage register raw 25644 = live 17039 + macro-block 18 + comment/dead 8587
|
||||
coverage volatile raw 4710 = live 2021 + macro-block 82 + comment/dead 2607
|
||||
coverage asm raw 45906 = live 38920 + macro-block 194 + comment/dead 6792
|
||||
coverage register raw 25517 = live 16912 + 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 16989 16989 0 7331 971 2488 16989 0 {'pin': 16989}
|
||||
B asm 21694 21681 13 8757 915 2128 12417 9277 {'instruction': 1580, 'barrier': 4201, 'gte': 6858, 'launder': 4452, 'keepalive': 1443, 'gte-lever': 462, 'gte-unsigned': 3, 'asm-body': 13, 'verbatim-body': 2682}
|
||||
A pins 16862 16862 0 7204 970 2487 16862 0 {'pin': 16862}
|
||||
B asm 21694 21681 13 8757 915 2128 12417 9277 {'verbatim-body': 2682, 'barrier': 4201, 'gte': 6858, 'gte-lever': 462, 'gte-unsigned': 3, 'launder': 4452, 'instruction': 1580, 'asm-body': 13, 'keepalive': 1443}
|
||||
C volatile 1590 1438 152 496 96 610 14 1576 {'decl-body': 58, 'decl-file': 152, 'cast': 1378, 'param': 2}
|
||||
D register 50 50 0 47 47 6 0 50 {'register': 50}
|
||||
E asm-label 7428 1005 6423 737 117 2080 0 7428 {'asm-label': 7428}
|
||||
F builtin 445 445 0 428 27 302 0 445 {'builtin': 445}
|
||||
G attribute 76 1 75 1 1 40 0 76 {'attribute': 76}
|
||||
UNION A–D: 12,268 bodies · 1,565 distinct (addresses normalized) · 299 multi-copy classes holding 11,002 bodies · by kind {'ov': 11709, 'shared': 249, 'main': 165, 'md': 135, 'resident': 10}
|
||||
THE PHASE'S NUMBER (pins + asm statements, GTE excluded): 29,140 sites in 9,005 bodies (1,280 distinct) · marked !FAKE 29,140 · UNMARKED 0
|
||||
UNION A–D: 12,141 bodies · 1,564 distinct (addresses normalized) · 298 multi-copy classes holding 10,875 bodies · by kind {'ov': 11583, 'shared': 248, 'main': 165, 'md': 135, 'resident': 10}
|
||||
THE PHASE'S NUMBER (pins + asm statements, GTE excluded): 29,013 sites in 8,878 bodies (1,279 distinct) · marked !FAKE 29,013 · 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: 16,989 · $0 773 · $sp 13 · with initializer 2,410 · volatile-qualified 134 · bare-name 15 · spellings {'__asm__': 16911, 'asm': 78}
|
||||
pins: 16,862 · $0 773 · $sp 13 · with initializer 2,283 · volatile-qualified 7 · bare-name 15 · spellings {'__asm__': 16784, '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': 4199, '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': 1558, 'instruction/via-macro': 22, 'keepalive/direct': 1443, 'launder/direct': 4008, 'launder/via-macro': 444, 'verbatim-body/direct': 2682}
|
||||
instruction mnemonics: {'addu': 834, 'move': 406, 'la': 142, 'lh': 134, 'addiu': 22, 'RTP_SND': 22, '.section': 7, 'lui': 4, 'and': 2, 'lw': 1, 'mult': 1, 'mfhi': 1, 'sll': 1, 'li': 1, 'nop': 1, 'srl': 1}
|
||||
gte mnemonics: {'gte_ldv0': 757, 'gte_stlvnl': 593, 'gte_stsxy': 447, 'gte_rtps': 437, 'gte_stflg': 415, 'gte_rtpt': 352, 'gte_SetRotMatrix': 246, 'gte_stsxy3': 236, 'gte_rtv0tr': 228, 'gte_SetTransMatrix': 226, 'gte_ldv3c': 184, 'gte_ldv3': 177, 'gte_ldrgb': 164, 'gte_stsv': 161, 'lwc2': 159, 'gte_stsz4': 149, 'gte_stsz3': 147, 'gte_stszotz': 134, 'gte_ldIR0z': 134, 'gte_ldIRGB': 134, 'gte_dpcl': 134, 'gte_stORGB': 134, 'gte_stsxy3_f3': 111, 'gte_nclip': 108, 'gte_stopz': 108, 'gte_stsxy3c': 108, 'gte_stclmv': 108, 'gte_stsxy3_ft3': 79, 'gte_rtir': 75, 'gte_ldclmv': 72}
|
||||
instruction mnemonics: {'addu': 834, 'move': 406, 'la': 142, 'lh': 134, '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 {'gte': 150, 'launder': 154, 'instruction': 9, 'barrier': 1}
|
||||
controls (R39):
|
||||
src/800.c func_800226C0 pins got 14 expected 45 N-A
|
||||
src/shared/ov/func_80178004.h pins got 8 expected 26 N-A
|
||||
ov_SC03_006 func_80184034 bare-name pins got 0 expected 3 N-A
|
||||
engine_prelude.h asm sites (a macro definition only) got 0 expected 0 OK
|
||||
elapsed 24.2 s
|
||||
elapsed 26.2 s
|
||||
|
||||
+183
-183
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"head": "724c68859",
|
||||
"head": "bb0e95c7c",
|
||||
"stamp": "b44c5a8a3423",
|
||||
"generated": "2026-09-10 08:47",
|
||||
"generated": "2026-09-10 10:25",
|
||||
"aliases": [
|
||||
"main",
|
||||
"ov_SC03_014",
|
||||
@@ -21,207 +21,207 @@
|
||||
"main": {
|
||||
"objects": 85,
|
||||
"identical": 85,
|
||||
"seconds": 6.413000000000001,
|
||||
"mean_s": 0.075
|
||||
"seconds": 6.9570000000000025,
|
||||
"mean_s": 0.082
|
||||
},
|
||||
"ov_SC03_014": {
|
||||
"objects": 32,
|
||||
"identical": 32,
|
||||
"seconds": 4.3950000000000005,
|
||||
"mean_s": 0.137
|
||||
"seconds": 4.567999999999999,
|
||||
"mean_s": 0.143
|
||||
},
|
||||
"ov_SC03_015": {
|
||||
"objects": 32,
|
||||
"identical": 32,
|
||||
"seconds": 4.304999999999999,
|
||||
"mean_s": 0.135
|
||||
"seconds": 4.443000000000001,
|
||||
"mean_s": 0.139
|
||||
},
|
||||
"ov_SC04_011": {
|
||||
"objects": 28,
|
||||
"identical": 28,
|
||||
"seconds": 3.6670000000000007,
|
||||
"mean_s": 0.131
|
||||
"seconds": 3.902000000000001,
|
||||
"mean_s": 0.139
|
||||
}
|
||||
},
|
||||
"per_object_seconds": {
|
||||
"build/src/800.o": 0.726,
|
||||
"build/src/800_b.o": 0.075,
|
||||
"build/src/800_b_2.o": 0.275,
|
||||
"build/src/800_b_o0a.o": 0.057,
|
||||
"build/src/800_c.o": 0.181,
|
||||
"build/src/800b2.o": 0.066,
|
||||
"build/src/apicard1.o": 0.059,
|
||||
"build/src/apicard2.o": 0.061,
|
||||
"build/src/apicard3.o": 0.079,
|
||||
"build/src/apicard4.o": 0.073,
|
||||
"build/src/apicard5.o": 0.061,
|
||||
"build/src/apicard6.o": 0.1,
|
||||
"build/src/apicard7.o": 0.083,
|
||||
"build/src/boot.o": 0.102,
|
||||
"build/src/gap.o": 0.058,
|
||||
"build/src/libapi1.o": 0.081,
|
||||
"build/src/libapi2.o": 0.055,
|
||||
"build/src/libc2_1.o": 0.06,
|
||||
"build/src/libc2_2.o": 0.054,
|
||||
"build/src/libcd1.o": 0.068,
|
||||
"build/src/libcd2.o": 0.06,
|
||||
"build/src/libetc.o": 0.052,
|
||||
"build/src/libgpu.o": 0.063,
|
||||
"build/src/libgpu2.o": 0.06,
|
||||
"build/src/libgs1.o": 0.057,
|
||||
"build/src/libgs2.o": 0.058,
|
||||
"build/src/libgs3.o": 0.064,
|
||||
"build/src/libgs4.o": 0.065,
|
||||
"build/src/libgs5.o": 0.062,
|
||||
"build/src/libgs6.o": 0.076,
|
||||
"build/src/libgs7.o": 0.06,
|
||||
"build/src/libgs8.o": 0.061,
|
||||
"build/src/libgte1.o": 0.059,
|
||||
"build/src/libgte10.o": 0.055,
|
||||
"build/src/libgte11.o": 0.061,
|
||||
"build/src/libgte12.o": 0.063,
|
||||
"build/src/libgte13.o": 0.063,
|
||||
"build/src/libgte14.o": 0.063,
|
||||
"build/src/libgte15.o": 0.052,
|
||||
"build/src/libgte16.o": 0.061,
|
||||
"build/src/libgte17.o": 0.063,
|
||||
"build/src/libgte18.o": 0.06,
|
||||
"build/src/libgte19.o": 0.065,
|
||||
"build/src/libgte2.o": 0.06,
|
||||
"build/src/libgte20.o": 0.059,
|
||||
"build/src/libgte21.o": 0.055,
|
||||
"build/src/libgte22.o": 0.069,
|
||||
"build/src/libgte23.o": 0.055,
|
||||
"build/src/libgte24.o": 0.06,
|
||||
"build/src/libgte25.o": 0.059,
|
||||
"build/src/libgte26.o": 0.069,
|
||||
"build/src/libgte27.o": 0.064,
|
||||
"build/src/libgte28.o": 0.061,
|
||||
"build/src/libgte29.o": 0.063,
|
||||
"build/src/libgte3.o": 0.059,
|
||||
"build/src/libgte30.o": 0.062,
|
||||
"build/src/libgte4.o": 0.062,
|
||||
"build/src/libgte5.o": 0.059,
|
||||
"build/src/libgte6.o": 0.061,
|
||||
"build/src/libgte7.o": 0.059,
|
||||
"build/src/libgte8.o": 0.063,
|
||||
"build/src/libgte9.o": 0.066,
|
||||
"build/src/libmcrd1.o": 0.075,
|
||||
"build/src/libmcrd2.o": 0.057,
|
||||
"build/src/libpad1.o": 0.066,
|
||||
"build/src/libpad2.o": 0.064,
|
||||
"build/src/sgap.o": 0.063,
|
||||
"build/src/sgap_2.o": 0.062,
|
||||
"build/src/sgap_3.o": 0.058,
|
||||
"build/src/sgap_4.o": 0.066,
|
||||
"build/src/800.o": 0.74,
|
||||
"build/src/800_b.o": 0.084,
|
||||
"build/src/800_b_2.o": 0.296,
|
||||
"build/src/800_b_o0a.o": 0.07,
|
||||
"build/src/800_c.o": 0.187,
|
||||
"build/src/800b2.o": 0.082,
|
||||
"build/src/apicard1.o": 0.086,
|
||||
"build/src/apicard2.o": 0.062,
|
||||
"build/src/apicard3.o": 0.068,
|
||||
"build/src/apicard4.o": 0.067,
|
||||
"build/src/apicard5.o": 0.086,
|
||||
"build/src/apicard6.o": 0.068,
|
||||
"build/src/apicard7.o": 0.07,
|
||||
"build/src/boot.o": 0.117,
|
||||
"build/src/gap.o": 0.083,
|
||||
"build/src/libapi1.o": 0.066,
|
||||
"build/src/libapi2.o": 0.066,
|
||||
"build/src/libc2_1.o": 0.062,
|
||||
"build/src/libc2_2.o": 0.06,
|
||||
"build/src/libcd1.o": 0.069,
|
||||
"build/src/libcd2.o": 0.059,
|
||||
"build/src/libetc.o": 0.061,
|
||||
"build/src/libgpu.o": 0.065,
|
||||
"build/src/libgpu2.o": 0.075,
|
||||
"build/src/libgs1.o": 0.056,
|
||||
"build/src/libgs2.o": 0.061,
|
||||
"build/src/libgs3.o": 0.067,
|
||||
"build/src/libgs4.o": 0.068,
|
||||
"build/src/libgs5.o": 0.067,
|
||||
"build/src/libgs6.o": 0.09,
|
||||
"build/src/libgs7.o": 0.068,
|
||||
"build/src/libgs8.o": 0.071,
|
||||
"build/src/libgte1.o": 0.065,
|
||||
"build/src/libgte10.o": 0.065,
|
||||
"build/src/libgte11.o": 0.065,
|
||||
"build/src/libgte12.o": 0.064,
|
||||
"build/src/libgte13.o": 0.071,
|
||||
"build/src/libgte14.o": 0.07,
|
||||
"build/src/libgte15.o": 0.063,
|
||||
"build/src/libgte16.o": 0.062,
|
||||
"build/src/libgte17.o": 0.064,
|
||||
"build/src/libgte18.o": 0.082,
|
||||
"build/src/libgte19.o": 0.069,
|
||||
"build/src/libgte2.o": 0.069,
|
||||
"build/src/libgte20.o": 0.066,
|
||||
"build/src/libgte21.o": 0.07,
|
||||
"build/src/libgte22.o": 0.062,
|
||||
"build/src/libgte23.o": 0.063,
|
||||
"build/src/libgte24.o": 0.082,
|
||||
"build/src/libgte25.o": 0.068,
|
||||
"build/src/libgte26.o": 0.073,
|
||||
"build/src/libgte27.o": 0.088,
|
||||
"build/src/libgte28.o": 0.077,
|
||||
"build/src/libgte29.o": 0.07,
|
||||
"build/src/libgte3.o": 0.07,
|
||||
"build/src/libgte30.o": 0.071,
|
||||
"build/src/libgte4.o": 0.065,
|
||||
"build/src/libgte5.o": 0.065,
|
||||
"build/src/libgte6.o": 0.07,
|
||||
"build/src/libgte7.o": 0.068,
|
||||
"build/src/libgte8.o": 0.068,
|
||||
"build/src/libgte9.o": 0.071,
|
||||
"build/src/libmcrd1.o": 0.084,
|
||||
"build/src/libmcrd2.o": 0.067,
|
||||
"build/src/libpad1.o": 0.071,
|
||||
"build/src/libpad2.o": 0.072,
|
||||
"build/src/sgap.o": 0.068,
|
||||
"build/src/sgap_2.o": 0.078,
|
||||
"build/src/sgap_3.o": 0.073,
|
||||
"build/src/sgap_4.o": 0.068,
|
||||
"build/src/sgap_5.o": 0.065,
|
||||
"build/src/sgap_6.o": 0.06,
|
||||
"build/src/sgap_8.o": 0.069,
|
||||
"build/src/snd1.o": 0.067,
|
||||
"build/src/snd10.o": 0.058,
|
||||
"build/src/snd11.o": 0.062,
|
||||
"build/src/snd12.o": 0.07,
|
||||
"build/src/snd2.o": 0.06,
|
||||
"build/src/snd3.o": 0.058,
|
||||
"build/src/snd4.o": 0.057,
|
||||
"build/src/snd5.o": 0.062,
|
||||
"build/src/snd6.o": 0.082,
|
||||
"build/src/snd7.o": 0.066,
|
||||
"build/src/snd8.o": 0.061,
|
||||
"build/src/snd9.o": 0.063,
|
||||
"build/src/ov_SC03_014/ov_SC03_014.o": 0.118,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_after.o": 0.451,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o": 0.386,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80135888.o": 0.063,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80135A4C.o": 0.057,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80135D20.o": 0.125,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_801380E0.o": 0.151,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8013C98C.o": 0.114,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8013F350.o": 0.074,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8013FFD8.o": 0.065,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80140608.o": 0.182,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8015444C.o": 0.076,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80154C24.o": 0.158,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_801588CC.o": 0.083,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80159C84.o": 0.061,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8015A3C8.o": 0.07,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8015AE2C.o": 0.085,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.o": 0.458,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8016AB6C.o": 0.236,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80171B4C.o": 0.094,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_801734BC.o": 0.17,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_801789AC.o": 0.058,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80178D40.o": 0.095,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8017A4AC.o": 0.07,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8017AE2C.o": 0.159,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8017EB7C.o": 0.193,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80184440.o": 0.045,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_801848E4.o": 0.267,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_o0b.o": 0.054,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_o0c.o": 0.055,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_o0d.o": 0.057,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_o0e.o": 0.065,
|
||||
"build/src/ov_SC03_015/ov_SC03_015.o": 0.108,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_after.o": 0.503,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o": 0.367,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80135888.o": 0.054,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80135A4C.o": 0.051,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80135D20.o": 0.101,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_801380E0.o": 0.138,
|
||||
"build/src/sgap_6.o": 0.064,
|
||||
"build/src/sgap_8.o": 0.068,
|
||||
"build/src/snd1.o": 0.072,
|
||||
"build/src/snd10.o": 0.064,
|
||||
"build/src/snd11.o": 0.063,
|
||||
"build/src/snd12.o": 0.062,
|
||||
"build/src/snd2.o": 0.07,
|
||||
"build/src/snd3.o": 0.065,
|
||||
"build/src/snd4.o": 0.064,
|
||||
"build/src/snd5.o": 0.066,
|
||||
"build/src/snd6.o": 0.08,
|
||||
"build/src/snd7.o": 0.065,
|
||||
"build/src/snd8.o": 0.062,
|
||||
"build/src/snd9.o": 0.073,
|
||||
"build/src/ov_SC03_014/ov_SC03_014.o": 0.126,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_after.o": 0.484,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8012ACE0.o": 0.384,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80135888.o": 0.061,
|
||||
"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.121,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_801380E0.o": 0.155,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8013C98C.o": 0.125,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8013F350.o": 0.081,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8013FFD8.o": 0.07,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80140608.o": 0.181,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8015444C.o": 0.069,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80154C24.o": 0.181,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_801588CC.o": 0.084,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80159C84.o": 0.067,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8015A3C8.o": 0.072,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8015AE2C.o": 0.091,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8015C32C.o": 0.473,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8016AB6C.o": 0.239,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80171B4C.o": 0.092,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_801734BC.o": 0.2,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_801789AC.o": 0.061,
|
||||
"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.062,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8017AE2C.o": 0.157,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_8017EB7C.o": 0.195,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_80184440.o": 0.051,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_jr_801848E4.o": 0.284,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_o0b.o": 0.056,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_o0c.o": 0.058,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_o0d.o": 0.055,
|
||||
"build/src/ov_SC03_014/ov_SC03_014_o0e.o": 0.068,
|
||||
"build/src/ov_SC03_015/ov_SC03_015.o": 0.118,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_after.o": 0.485,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8012ACE0.o": 0.386,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80135888.o": 0.049,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80135A4C.o": 0.052,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80135D20.o": 0.108,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_801380E0.o": 0.148,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8013C98C.o": 0.107,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8013F350.o": 0.067,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8013FFD8.o": 0.057,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80140608.o": 0.17,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8015444C.o": 0.067,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80154C24.o": 0.159,
|
||||
"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.067,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8015A3C8.o": 0.069,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8015AE2C.o": 0.089,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8015C32C.o": 0.429,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8016AB6C.o": 0.245,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80171B4C.o": 0.097,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_801734BC.o": 0.192,
|
||||
"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.092,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8017A4AC.o": 0.063,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8017AE2C.o": 0.143,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8017EB7C.o": 0.18,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80184440.o": 0.056,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_801848E4.o": 0.256,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_o0b.o": 0.06,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_o0c.o": 0.055,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_o0d.o": 0.055,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_o0e.o": 0.068,
|
||||
"build/src/ov_SC04_011/ov_SC04_011.o": 0.104,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_after.o": 0.389,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o": 0.333,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_80135888.o": 0.05,
|
||||
"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.117,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_801380E0.o": 0.154,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8013C98C.o": 0.097,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8013F350.o": 0.063,
|
||||
"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.161,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8015444C.o": 0.068,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_80154C24.o": 0.13,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_801588CC.o": 0.09,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8013F350.o": 0.075,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8013FFD8.o": 0.062,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80140608.o": 0.178,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8015444C.o": 0.07,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80154C24.o": 0.165,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_801588CC.o": 0.085,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80159C84.o": 0.063,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8015A3C8.o": 0.062,
|
||||
"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.449,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8016AB6C.o": 0.266,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80171B4C.o": 0.096,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_801734BC.o": 0.206,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_801789AC.o": 0.062,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80178D40.o": 0.095,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8017A4AC.o": 0.064,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8017AE2C.o": 0.159,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_8017EB7C.o": 0.197,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_80184440.o": 0.055,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_jr_801848E4.o": 0.254,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_o0b.o": 0.057,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_o0c.o": 0.058,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_o0d.o": 0.057,
|
||||
"build/src/ov_SC03_015/ov_SC03_015_o0e.o": 0.064,
|
||||
"build/src/ov_SC04_011/ov_SC04_011.o": 0.116,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_after.o": 0.434,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8012ACE0.o": 0.339,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_80135888.o": 0.048,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_80135A4C.o": 0.048,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_80135D20.o": 0.112,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_801380E0.o": 0.145,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8013C98C.o": 0.11,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8013F350.o": 0.077,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8013FFD8.o": 0.064,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_80140608.o": 0.179,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8015444C.o": 0.07,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_80154C24.o": 0.168,
|
||||
"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.063,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8015A3C8.o": 0.058,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8015AE2C.o": 0.081,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.o": 0.342,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8016AB6C.o": 0.206,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_80171B4C.o": 0.088,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_801734BC.o": 0.169,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8015A3C8.o": 0.065,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8015AE2C.o": 0.1,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8015C32C.o": 0.351,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8016AB6C.o": 0.216,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_80171B4C.o": 0.09,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_801734BC.o": 0.188,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_801789AC.o": 0.055,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_80178D40.o": 0.084,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8017A4AC.o": 0.058,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8017AE2C.o": 0.089,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8017D494.o": 0.401,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_o0b.o": 0.049,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_o0c.o": 0.054
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8017A4AC.o": 0.059,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8017AE2C.o": 0.092,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_jr_8017D494.o": 0.432,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_o0b.o": 0.054,
|
||||
"build/src/ov_SC04_011/ov_SC04_011_o0c.o": 0.048
|
||||
},
|
||||
"ok": true,
|
||||
"seconds": 2.2
|
||||
"seconds": 2.3
|
||||
}
|
||||
|
||||
@@ -21988,3 +21988,130 @@
|
||||
{"ts": "2026-09-10 09:46:34", "label": "s7", "rung": "G", "calib": {"head": "724c68859", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_125/ov_SC03_125_jr_80182BA0.c", "fn": "func_80182BA0", "addr": 2149067680, "aliases": null, "header": false, "includers": 0, "nhash_before": "ffb320053c1c12f0d8e10af37b5c8f190ccb67d1", "nhash_after": "2aad8adcac02635e09c0340f865babc765020841", "source": ".run/P36/engine/bodies/ov_SC03_125__func_80182BA0.c", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.062, "objects": ["build/src/ov_SC03_125/ov_SC03_125_jr_80182BA0.o"], "before_text": "void func_80182BA0(void *a0) {\n\n extern u8 D_80078E78[];\n extern void *D_801A6A20[];\n extern s32 D_801A69F0;\n extern s32 D_801A6A08;\n void *s2 = a0;\n register u8 *p __asm__(\"$17\"); // !FAKE: pin $17 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n void *s0;\n s32 v0;\n s16 v1;\n\n v0 = func_80029504();\n v1 = *(s16 *)((s32)s2 + 0x70);\n p = D_80078E78;\n s0 = D_801A6A20[v1];\n v1 -= 8;\n switch (v1) {\n case 1:\n if (p[0x42] == 0) {\n s0 = &D_801A69F0;\n }\n break;\n case 0:\n if (p[0x42] == 3) {\n s0 = &D_801A69F0;\n }\n break;\n case 4:\n if ((u32)(v0 - 0x12C) < 0x12C) {\n if ((func_80029178(0xFA) & 0xFF) != 0) {\n s0 = &D_801A6A08;\n }\n }\n break;\n case 6:\n if (p[0x42] == 6) {\n s0 = &D_801A69F0;\n }\n if ((u32)(v0 - 0x64) < 0x1F4) {\n s0 = &D_801A6A08;\n }\n if (func_80181C74() == 1) {\n s0 = &D_801A6A08;\n }\n break;\n case 5:\n if (p[0x42] == 2) {\n s0 = &D_801A69F0;\n }\n if (func_80181B30() == 3) {\n s0 = &D_801A6A08;\n }\n if (func_80181C74() == 1) {\n s0 = &D_801A6A08;\n }\n break;\n }\n ((void (*)(s32, s32))func_80178CBC)((s32)s2, (s32)s0);\n}\n", "after_text": "void func_80182BA0(void *a0) {\n\n extern u8 D_80078E78[];\n extern void *D_801A6A20[];\n extern s32 D_801A69F0;\n extern s32 D_801A6A08;\n void *s2 = a0;\n u8 *p;\n void *s0;\n s32 v0;\n s16 v1;\n\n p = D_80078E78;\n v0 = func_80029504();\n v1 = *(s16 *)((s32)s2 + 0x70);\n s0 = D_801A6A20[v1];\n v1 -= 8;\n switch (v1) {\n case 1:\n if (p[0x42] == 0) {\n s0 = &D_801A69F0;\n }\n break;\n case 0:\n if (p[0x42] == 3) {\n s0 = &D_801A69F0;\n }\n break;\n case 4:\n if ((u32)(v0 - 0x12C) < 0x12C) {\n if ((func_80029178(0xFA) & 0xFF) != 0) {\n s0 = &D_801A6A08;\n }\n }\n break;\n case 6:\n if (p[0x42] == 6) {\n s0 = &D_801A69F0;\n }\n if ((u32)(v0 - 0x64) < 0x1F4) {\n s0 = &D_801A6A08;\n }\n if (func_80181C74() == 1) {\n s0 = &D_801A6A08;\n }\n break;\n case 5:\n if (p[0x42] == 2) {\n s0 = &D_801A69F0;\n }\n if (func_80181B30() == 3) {\n s0 = &D_801A6A08;\n }\n if (func_80181C74() == 1) {\n s0 = &D_801A6A08;\n }\n break;\n }\n ((void (*)(s32, s32))func_80178CBC)((s32)s2, (s32)s0);\n}\n"}
|
||||
{"ts": "2026-09-10 09:48:19", "label": "s7", "rung": "G", "calib": {"head": "724c68859", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.c", "fn": "func_8017DCE4", "addr": 2149047524, "aliases": null, "header": false, "includers": 0, "nhash_before": "aab1dc6e07535da7c55ea73fcf1335895a1f8bde", "nhash_after": "bc43b84d070c5b948377a649a9d94d623c0a14d9", "source": ".run/P36/engine/bodies/ov_SC03_001__func_8017DCE4.c", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.216, "objects": ["build/src/ov_SC03_001/ov_SC03_001_jr_8017AE2C.o"], "before_text": "void func_8017DCE4(s32 a0)\n{\n register s32 pv __asm__(\"$16\") = a0; // !FAKE: pin $16 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n s32 s1;\n s32 flags;\n TmpVec_8017DCE4 tmp;\n s32 v0;\n\n s1 = func_8012E544(0xAD);\n if (s1 == 0) {\n func_8012C218((void *)pv);\n return;\n }\n\n func_8012B1B4(pv, (s32)&D_80191020);\n flags = func_8012CBCC(pv);\n\n if (flags & 0x6000) {\n *(s16 *)(pv + 0x16) = -6;\n }\n\n if (flags & 0x8000) {\n *(s32 *)(pv + 4) += *(s32 *)(pv + 0x10);\n *(s32 *)(pv + 8) += *(s32 *)(pv + 0x14);\n *(s32 *)(pv + 0xC) += *(s32 *)(pv + 0x18);\n }\n\n tmp.vx = *(u16 *)(s1 + 6) + 0x20;\n tmp.vz = *(u16 *)(s1 + 0xE) + 0x20;\n v0 = func_8012B744((void *)(pv + 4), &tmp);\n\n {\n s32 r = func_8012B608(*(s16 *)(*(s32 *)(pv + 0x20) + 0x12), v0, 4);\n *(u16 *)(*(s32 *)(pv + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(pv + 0x20) + 0x12) + r;\n }\n}\n", "after_text": "void func_8017DCE4(s32 a0)\n{\n s32 pv = a0;\n s32 s1;\n s32 flags;\n TmpVec_8017DCE4 tmp;\n s32 v0;\n\n s1 = func_8012E544(0xAD);\n if (s1 == 0) {\n func_8012C218((void *)pv);\n return;\n }\n\n do { func_8012B1B4(pv, (s32)&D_80191020); } while (0);\n flags = func_8012CBCC(pv);\n\n if (flags & 0x6000) {\n *(s16 *)(pv + 0x16) = -6;\n }\n\n if (flags & 0x8000) {\n *(s32 *)(pv + 4) += *(s32 *)(pv + 0x10);\n *(s32 *)(pv + 8) += *(s32 *)(pv + 0x14);\n *(s32 *)(pv + 0xC) += *(s32 *)(pv + 0x18);\n }\n\n tmp.vx = *(u16 *)(s1 + 6) + 0x20;\n tmp.vz = *(u16 *)(s1 + 0xE) + 0x20;\n v0 = func_8012B744((void *)(pv + 4), &tmp);\n\n {\n s32 r = func_8012B608(*(s16 *)(*(s32 *)(pv + 0x20) + 0x12), v0, 4);\n *(u16 *)(*(s32 *)(pv + 0x20) + 0x12) =\n *(u16 *)(*(s32 *)(pv + 0x20) + 0x12) + r;\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:00:07", "label": "s7", "rung": "G", "calib": {"head": "724c68859", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.c", "fn": "func_8017F31C", "addr": 2149053212, "aliases": null, "header": false, "includers": 0, "nhash_before": "6a1ba40b75f42b970abc4e9105f338b2644e9fe7", "nhash_after": "8ac78b40c86e42290a8b80db3a698a71c5aeb64c", "source": ".run/P36/engine/bodies/ov_SC07_010__func_8017F31C.c", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.177, "objects": ["build/src/ov_SC07_010/ov_SC07_010_jr_8017AE2C.o"], "before_text": "void func_8017F31C(s32 a0) {\n register s32 s1 __asm__(\"$17\") = a0; // !FAKE: pin $17 \u2014 NEEDED DIFFERS (P36 rung B tus9)\n s32 s0;\n s32 v0;\n s32 s2;\n\n s2 = (*(s16 *)(s1 + 0x70) << 6) + (s32)&D_801A7D0C;\n v0 = ((s32 (*)(void))func_8012C194)();\n __asm__ volatile(\"addu %0,%1,$0\" : \"=r\"(s0) : \"r\"(v0)); // !FAKE: instruction addu \u2014 NEEDED DIFFERS (P36 rung B tus9)\n *(s32 *)(s1 + 0x20) = v0;\n\n if (v0 == 0) {\n func_8012CAE4((void *)s1);\n } else {\n func_8001CD9C(s0, (void *)s2);\n func_800233CC((void *)s2, 0xA0);\n *(s16 *)(s0 + 0x2C) = 3;\n *(s16 *)(s0 + 0x1A) = 0;\n *(s16 *)(s0 + 0x18) = 0;\n *(s32 *)(s0 + 4) |= 0x50000000;\n *(s32 *)s2 = 0xFFFFFF;\n *(s32 *)(s2 + 4) = 0x10;\n func_8012AD50((void *)s1);\n }\n}\n", "after_text": "void func_8017F31C(s32 a0) {\n s32 s1 = a0;\n s32 s0;\n s32 v0;\n s32 s2;\n\n do { s2 = (*(s16 *)(s1 + 0x70) << 6) + (s32)&D_801A7D0C; } while (0);\n v0 = ((s32 (*)(void))func_8012C194)();\n s0 = v0;\n *(s32 *)(s1 + 0x20) = v0;\n\n if (v0 == 0) {\n func_8012CAE4((void *)s1);\n } else {\n func_8001CD9C(s0, (void *)s2);\n func_800233CC((void *)s2, 0xA0);\n *(s16 *)(s0 + 0x2C) = 3;\n *(s16 *)(s0 + 0x1A) = 0;\n *(s16 *)(s0 + 0x18) = 0;\n *(s32 *)(s0 + 4) |= 0x50000000;\n *(s32 *)s2 = 0xFFFFFF;\n *(s32 *)(s2 + 4) = 0x10;\n func_8012AD50((void *)s1);\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:01", "label": "a7", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_011/ov_SC04_011.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "T7 agent a7", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC04_011/ov_SC04_011.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801F1640 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801F1640; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B t3_tus1)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801F1640;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:05", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_000/ov_SC01_000.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC01_000/ov_SC01_000.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A5878 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A5878; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A5878;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:05", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_001/ov_SC01_001.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC01_001/ov_SC01_001.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801F3158 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801F3158; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801F3158;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:06", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_004/ov_SC01_004.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.085, "objects": ["build/src/ov_SC01_004/ov_SC01_004.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_80190360 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_80190360; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_80190360;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:06", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_008/ov_SC01_008.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC01_008/ov_SC01_008.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A3570 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A3570; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A3570;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:06", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_074/ov_SC01_074.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.087, "objects": ["build/src/ov_SC01_074/ov_SC01_074.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019BD00 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019BD00; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019BD00;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:06", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_009/ov_SC01_009.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC01_009/ov_SC01_009.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801F33F0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801F33F0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801F33F0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:06", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_077/ov_SC01_077_a.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC01_077/ov_SC01_077_a.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801DAAC0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801DAAC0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801DAAC0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:06", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_084/ov_SC01_084.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.085, "objects": ["build/src/ov_SC01_084/ov_SC01_084.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C7B88 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C7B88; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C7B88;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:06", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_080/ov_SC01_080.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC01_080/ov_SC01_080.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C7EE0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C7EE0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C7EE0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:06", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_005/ov_SC02_005.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC02_005/ov_SC02_005.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801E4BE0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801E4BE0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801E4BE0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:07", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC01_005/ov_SC01_005.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.168, "objects": ["build/src/ov_SC01_005/ov_SC01_005.o", "build/src/ov_SC01_006/ov_SC01_006.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801CDFC0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801CDFC0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801CDFC0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:07", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_004/ov_SC02_004.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC02_004/ov_SC02_004.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_80196358 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_80196358; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_80196358;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:07", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_015/ov_SC02_015.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC02_015/ov_SC02_015.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_80190630 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_80190630; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_80190630;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:07", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_016/ov_SC02_016.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC02_016/ov_SC02_016.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B4A68 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B4A68; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B4A68;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:07", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_011/ov_SC02_011.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC02_011/ov_SC02_011.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801EBA10 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801EBA10; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801EBA10;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:07", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_021/ov_SC02_021.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC02_021/ov_SC02_021.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_80193830 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_80193830; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_80193830;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:07", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_017/ov_SC02_017.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.088, "objects": ["build/src/ov_SC02_017/ov_SC02_017.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801EFCC8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801EFCC8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801EFCC8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:07", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_027/ov_SC02_027.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.089, "objects": ["build/src/ov_SC02_027/ov_SC02_027.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801DA9D0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801DA9D0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801DA9D0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:07", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_026/ov_SC02_026.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC02_026/ov_SC02_026.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801D0250 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801D0250; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801D0250;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:08", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_000/ov_SC02_000.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.166, "objects": ["build/src/ov_SC02_000/ov_SC02_000.o", "build/src/ov_SC02_003/ov_SC02_003.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801E87C0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801E87C0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801E87C0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:08", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_031/ov_SC02_031.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC02_031/ov_SC02_031.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B7AA0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B7AA0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B7AA0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:08", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_035/ov_SC02_035.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC02_035/ov_SC02_035.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801BE9D8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801BE9D8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801BE9D8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:08", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_039/ov_SC02_039.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC02_039/ov_SC02_039.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A0D90 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A0D90; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A0D90;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:08", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_028/ov_SC02_028.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC02_028/ov_SC02_028.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801D35D0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801D35D0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801D35D0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:08", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC02_041/ov_SC02_041.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.079, "objects": ["build/src/ov_SC02_041/ov_SC02_041.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B9668 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B9668; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B9668;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:08", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_001/ov_SC03_001.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.079, "objects": ["build/src/ov_SC03_001/ov_SC03_001.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801EF3F8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801EF3F8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801EF3F8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:08", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_003/ov_SC03_003.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC03_003/ov_SC03_003.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8018FB08 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8018FB08; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8018FB08;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:08", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_002/ov_SC03_002.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC03_002/ov_SC03_002.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801CBAE0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801CBAE0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801CBAE0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:09", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_006/ov_SC03_006.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC03_006/ov_SC03_006.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801F7848 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801F7848; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801F7848;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:09", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_007/ov_SC03_007.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC03_007/ov_SC03_007.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801EB258 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801EB258; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801EB258;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:09", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_010/ov_SC03_010.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC03_010/ov_SC03_010.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A0160 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A0160; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A0160;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:09", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_011/ov_SC03_011.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.079, "objects": ["build/src/ov_SC03_011/ov_SC03_011.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A2390 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A2390; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A2390;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:09", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_012/ov_SC03_012.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.08, "objects": ["build/src/ov_SC03_012/ov_SC03_012.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801950F0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801950F0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801950F0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:09", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_023/ov_SC03_023.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC03_023/ov_SC03_023.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_80198D18 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_80198D18; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_80198D18;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:09", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_013/ov_SC03_013.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.08, "objects": ["build/src/ov_SC03_013/ov_SC03_013.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801AD4E8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801AD4E8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801AD4E8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:09", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_024/ov_SC03_024.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.079, "objects": ["build/src/ov_SC03_024/ov_SC03_024.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C17E0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C17E0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C17E0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:09", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_028/ov_SC03_028.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC03_028/ov_SC03_028.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801EC598 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801EC598; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801EC598;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:09", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_029/ov_SC03_029.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC03_029/ov_SC03_029.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801D99D8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801D99D8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801D99D8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:10", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_030/ov_SC03_030.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.078, "objects": ["build/src/ov_SC03_030/ov_SC03_030.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801E1BD0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801E1BD0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801E1BD0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:10", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_089/ov_SC03_089.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.078, "objects": ["build/src/ov_SC03_089/ov_SC03_089.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C68B0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C68B0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C68B0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:10", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_031/ov_SC03_031.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.079, "objects": ["build/src/ov_SC03_031/ov_SC03_031.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C6238 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C6238; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C6238;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:10", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_090/ov_SC03_090.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.079, "objects": ["build/src/ov_SC03_090/ov_SC03_090.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801CBD20 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801CBD20; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801CBD20;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:10", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_091/ov_SC03_091.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.079, "objects": ["build/src/ov_SC03_091/ov_SC03_091.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801D2670 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801D2670; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801D2670;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:10", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_094/ov_SC03_094.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC03_094/ov_SC03_094.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801D3228 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801D3228; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801D3228;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:10", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_092/ov_SC03_092.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.08, "objects": ["build/src/ov_SC03_092/ov_SC03_092.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B3018 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B3018; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B3018;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:10", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_093/ov_SC03_093.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.079, "objects": ["build/src/ov_SC03_093/ov_SC03_093.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801CC670 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801CC670; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801CC670;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:10", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_014/ov_SC03_014.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.161, "objects": ["build/src/ov_SC03_014/ov_SC03_014.o", "build/src/ov_SC03_015/ov_SC03_015.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801EAFD0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801EAFD0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801EAFD0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:11", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_095/ov_SC03_095.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC03_095/ov_SC03_095.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019BE28 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019BE28; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019BE28;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:11", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_097/ov_SC03_097.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC03_097/ov_SC03_097.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801AAE60 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801AAE60; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801AAE60;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:11", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_098/ov_SC03_098.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC03_098/ov_SC03_098.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C5848 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C5848; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C5848;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:11", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_096/ov_SC03_096.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.08, "objects": ["build/src/ov_SC03_096/ov_SC03_096.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019A8E0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019A8E0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019A8E0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:11", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_099/ov_SC03_099.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC03_099/ov_SC03_099.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801BF3F0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801BF3F0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801BF3F0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:11", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_100/ov_SC03_100.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.085, "objects": ["build/src/ov_SC03_100/ov_SC03_100.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C88F8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C88F8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C88F8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:11", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_101/ov_SC03_101.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC03_101/ov_SC03_101.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019E1B8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019E1B8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019E1B8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:11", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_102/ov_SC03_102.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC03_102/ov_SC03_102.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B9BB8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B9BB8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B9BB8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:11", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_103/ov_SC03_103.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC03_103/ov_SC03_103.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C4D68 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C4D68; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C4D68;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:12", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_104/ov_SC03_104.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC03_104/ov_SC03_104.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C0428 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C0428; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C0428;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:12", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_109/ov_SC03_109.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC03_109/ov_SC03_109.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019A440 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019A440; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019A440;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:12", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_108/ov_SC03_108.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC03_108/ov_SC03_108.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A1A38 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A1A38; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A1A38;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:12", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_105/ov_SC03_105.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC03_105/ov_SC03_105.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801BCCB0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801BCCB0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801BCCB0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:12", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_113/ov_SC03_113.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.085, "objects": ["build/src/ov_SC03_113/ov_SC03_113.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A5C80 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A5C80; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A5C80;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:12", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_110/ov_SC03_110.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC03_110/ov_SC03_110.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A2470 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A2470; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A2470;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:12", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_112/ov_SC03_112.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.085, "objects": ["build/src/ov_SC03_112/ov_SC03_112.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801AD0E0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801AD0E0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801AD0E0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:12", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_111/ov_SC03_111.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC03_111/ov_SC03_111.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B9B18 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B9B18; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B9B18;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:12", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_114/ov_SC03_114.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC03_114/ov_SC03_114.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A97F8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A97F8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A97F8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:13", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_116/ov_SC03_116.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC03_116/ov_SC03_116.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_80197CE0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_80197CE0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_80197CE0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:13", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_117/ov_SC03_117.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.079, "objects": ["build/src/ov_SC03_117/ov_SC03_117.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801CE8D8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801CE8D8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801CE8D8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:13", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_115/ov_SC03_115.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC03_115/ov_SC03_115.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801950D0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801950D0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801950D0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:13", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_121/ov_SC03_121.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.08, "objects": ["build/src/ov_SC03_121/ov_SC03_121.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801AEF40 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801AEF40; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801AEF40;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:13", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_125/ov_SC03_125.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC03_125/ov_SC03_125.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C44D0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C44D0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C44D0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:13", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_124/ov_SC03_124.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.08, "objects": ["build/src/ov_SC03_124/ov_SC03_124.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801E2578 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801E2578; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801E2578;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:13", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_000/ov_SC04_000.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC04_000/ov_SC04_000.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801AAFE8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801AAFE8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801AAFE8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:13", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_003/ov_SC04_003.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC04_003/ov_SC04_003.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019BB80 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019BB80; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019BB80;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:13", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_004/ov_SC04_004.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC04_004/ov_SC04_004.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B3BE8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B3BE8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B3BE8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:13", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_005/ov_SC04_005.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC04_005/ov_SC04_005.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C22C0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C22C0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C22C0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:14", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_002/ov_SC04_002.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC04_002/ov_SC04_002.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C16C8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C16C8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C16C8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:14", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_006/ov_SC04_006.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC04_006/ov_SC04_006.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019DD60 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019DD60; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019DD60;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:14", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_008/ov_SC04_008.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC04_008/ov_SC04_008.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_80193450 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_80193450; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_80193450;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:14", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC03_118/ov_SC03_118.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.163, "objects": ["build/src/ov_SC03_118/ov_SC03_118.o", "build/src/ov_SC03_119/ov_SC03_119.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801D47E0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801D47E0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801D47E0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:14", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_009/ov_SC04_009.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC04_009/ov_SC04_009.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_80198200 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_80198200; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_80198200;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:14", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_007/ov_SC04_007.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC04_007/ov_SC04_007.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B5B20 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B5B20; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B5B20;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:14", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_010/ov_SC04_010.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC04_010/ov_SC04_010.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8018F6D8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8018F6D8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8018F6D8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:14", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_012/ov_SC04_012.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC04_012/ov_SC04_012.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801931D0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801931D0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801931D0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:15", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_015/ov_SC04_015.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC04_015/ov_SC04_015.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C9370 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C9370; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C9370;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:15", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_016/ov_SC04_016.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC04_016/ov_SC04_016.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801AC270 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801AC270; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801AC270;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:15", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_000/ov_SC05_000.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC05_000/ov_SC05_000.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019ABE8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019ABE8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019ABE8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:15", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_020/ov_SC04_020.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.085, "objects": ["build/src/ov_SC04_020/ov_SC04_020.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801BC740 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801BC740; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801BC740;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:15", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_002/ov_SC05_002.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC05_002/ov_SC05_002.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019FF50 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019FF50; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019FF50;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:15", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_001/ov_SC05_001.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.086, "objects": ["build/src/ov_SC05_001/ov_SC05_001.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B5F98 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B5F98; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B5F98;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:15", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_003/ov_SC05_003.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.085, "objects": ["build/src/ov_SC05_003/ov_SC05_003.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801ACA60 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801ACA60; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801ACA60;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:15", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_004/ov_SC05_004.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC05_004/ov_SC05_004.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019F2B8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019F2B8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019F2B8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:15", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_005/ov_SC05_005.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC05_005/ov_SC05_005.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B1FC0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B1FC0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B1FC0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:15", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_006/ov_SC05_006.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.086, "objects": ["build/src/ov_SC05_006/ov_SC05_006.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801900F0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801900F0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801900F0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:16", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_007/ov_SC05_007.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC05_007/ov_SC05_007.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019CE90 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019CE90; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019CE90;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:16", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC04_018/ov_SC04_018.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 2, "seconds": 0.163, "objects": ["build/src/ov_SC04_018/ov_SC04_018.o", "build/src/ov_SC04_019/ov_SC04_019.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801E7AB8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801E7AB8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801E7AB8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:16", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_010/ov_SC05_010.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC05_010/ov_SC05_010.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801C7FC0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801C7FC0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801C7FC0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:16", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_009/ov_SC05_009.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.087, "objects": ["build/src/ov_SC05_009/ov_SC05_009.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_80196BD8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_80196BD8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_80196BD8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:16", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_008/ov_SC05_008.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.088, "objects": ["build/src/ov_SC05_008/ov_SC05_008.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A1278 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A1278; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A1278;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:16", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_011/ov_SC05_011.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC05_011/ov_SC05_011.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019D170 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019D170; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019D170;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:16", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_017/ov_SC05_017.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC05_017/ov_SC05_017.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801ED918 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801ED918; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801ED918;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:16", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC05_018/ov_SC05_018.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC05_018/ov_SC05_018.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801E6820 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801E6820; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801E6820;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:17", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_000/ov_SC06_000.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.086, "objects": ["build/src/ov_SC06_000/ov_SC06_000.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B20E0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B20E0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B20E0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:17", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_006/ov_SC06_006.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC06_006/ov_SC06_006.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801F8AF8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801F8AF8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801F8AF8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:17", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_008/ov_SC06_008.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC06_008/ov_SC06_008.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801AA7C8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801AA7C8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801AA7C8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:17", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_011/ov_SC06_011.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC06_011/ov_SC06_011.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801ABCE8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801ABCE8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801ABCE8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:17", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_010/ov_SC06_010.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.08, "objects": ["build/src/ov_SC06_010/ov_SC06_010.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B2C10 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B2C10; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B2C10;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:17", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_014/ov_SC06_014.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.08, "objects": ["build/src/ov_SC06_014/ov_SC06_014.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A15B0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A15B0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A15B0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:17", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_013/ov_SC06_013.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC06_013/ov_SC06_013.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019AB98 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019AB98; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019AB98;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:17", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_016/ov_SC06_016.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC06_016/ov_SC06_016.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A0200 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A0200; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A0200;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:17", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_018/ov_SC06_018.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC06_018/ov_SC06_018.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801D5B30 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801D5B30; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801D5B30;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:17", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_015/ov_SC06_015.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC06_015/ov_SC06_015.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_80194990 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_80194990; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_80194990;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:18", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_020/ov_SC06_020.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC06_020/ov_SC06_020.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801BA980 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801BA980; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801BA980;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:18", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_022/ov_SC06_022.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC06_022/ov_SC06_022.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801E2200 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801E2200; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801E2200;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:18", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_024/ov_SC06_024.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC06_024/ov_SC06_024.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801E18F8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801E18F8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801E18F8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:18", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_025/ov_SC06_025.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC06_025/ov_SC06_025.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801B2218 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801B2218; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801B2218;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:18", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_027/ov_SC06_027.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.084, "objects": ["build/src/ov_SC06_027/ov_SC06_027.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8019D3C0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8019D3C0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8019D3C0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:18", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_029/ov_SC06_029.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC06_029/ov_SC06_029.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801E2120 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801E2120; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801E2120;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:18", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_032/ov_SC06_032.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC06_032/ov_SC06_032.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801D1100 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801D1100; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801D1100;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:18", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_030/ov_SC06_030.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.085, "objects": ["build/src/ov_SC06_030/ov_SC06_030.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801BA018 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801BA018; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801BA018;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:18", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC06_033/ov_SC06_033.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC06_033/ov_SC06_033.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801D0F80 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801D0F80; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801D0F80;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:19", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_001/ov_SC07_001.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.083, "objects": ["build/src/ov_SC07_001/ov_SC07_001.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801AAEA0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801AAEA0; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801AAEA0;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:19", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_008/ov_SC07_008.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC07_008/ov_SC07_008.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801966D8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801966D8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801966D8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:19", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_000/ov_SC07_000.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.082, "objects": ["build/src/ov_SC07_000/ov_SC07_000.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801D0C78 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801D0C78; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801D0C78;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:19", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_002/ov_SC07_002.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.079, "objects": ["build/src/ov_SC07_002/ov_SC07_002.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A0068 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A0068; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A0068;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:19", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/ov_SC07_009/ov_SC07_009.c", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": false, "includers": 0, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 1, "seconds": 0.081, "objects": ["build/src/ov_SC07_009/ov_SC07_009.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_801A3D68 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_801A3D68; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B tus7)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_801A3D68;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
{"ts": "2026-09-10 10:25:19", "label": "a7p", "rung": "E", "calib": {"head": "bb0e95c7c", "stamp": "b44c5a8a3423"}, "tu": "src/shared/ov/func_801287B8__96084aee.h", "fn": "func_801287B8", "addr": 2148698040, "aliases": null, "header": true, "includers": 3, "nhash_before": "1b937a9e03055da402e38f7d7fd7936503fba871", "nhash_after": "ed1d4501d3b3cc6246f418e3a8ba96938231a660", "source": "propagate:src/ov_SC04_011/ov_SC04_011.c:func_801287B8", "verdict": "LEVER-FREE", "sites": [], "compiles": 3, "seconds": 0.252, "objects": ["build/src/ov_SC03_126/ov_SC03_126.o", "build/src/ov_SC04_021/ov_SC04_021.o", "build/src/ov_SC05_019/ov_SC05_019.o"], "before_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n /* D_8018FAB8 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded\n * lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */\n register volatile s32 *p __asm__(\"$4\") = &D_8018FAB8; // !FAKE: pin $4 \u2014 NEEDED DIFFERS (P36 rung B headers1)\n if (*p == 0) {\n func_8013BC7C();\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n", "after_text": "void func_801287B8(void) {\n func_80129CF8();\n func_8017849C();\n ((void (*)(void *))func_8014FDF4)(&D_80126B58);\n ((void (*)(void *))func_801505FC)(&D_80126B58);\n func_801508B4(&D_80126B58);\n func_80165E90();\n func_801627E8();\n func_80162B1C();\n func_80165CA0();\n func_80129010();\n func_8013CA14();\n func_800190AC();\n func_8012956C();\n func_8016E95C();\n func_801754A8();\n {\n s32 *p = &D_8018FAB8;\n\n if (*p == 0) {\n ((void (*)(void *))func_8013BC7C)(p);\n }\n }\n func_8013BCDC();\n func_801379FC();\n D_800B99DA++;\n if (D_800B9A64 != 0) {\n func_8001212C();\n }\n}\n"}
|
||||
|
||||
@@ -16,3 +16,4 @@ date milestone head sites_AB pins asm bodies_AB distinct_AB marked unmarked gte_
|
||||
2026-09-10 S102 T7 s5 — the first broad TAIL sweep with R15/R16/R17/R18: 285 of 800 bodies closed lever-free, no drafting tokens 449acd8cb 29204 17029 12175 9035 1308 29204 0 462 314 1590 50 7428 445 76
|
||||
2026-09-10 S102 T7 s6 — the last never-attempted exemplars: 25 of 337; the fresh pool is now empty 67e91ad4d 29148 16996 12152 9010 1283 29148 0 462 314 1590 50 7428 445 76
|
||||
2026-09-10 S102 T7 s7 (stopped early to restore agent cadence) — 5 of 207 judged at the wider width 724c68859 29140 16989 12151 9005 1280 29140 0 462 314 1590 50 7428 445 76
|
||||
2026-09-10 S102 T7 a7 — func_801287B8: a truncated local extern was faking a pin; the missing call argument restored through a function-pointer cast (127 bodies) bb0e95c7c 29013 16862 12151 8878 1279 29013 0 462 314 1590 50 7428 445 76
|
||||
|
||||
|
+4
-1
@@ -62,6 +62,7 @@ counted, not marked). E, F and G belong to the canonical type layer and are the
|
||||
| 2026-09-10 | S102 T7 s5 — the first broad TAIL sweep with R15/R16/R17/R18: 285 of 800 bodies closed lever-free, no drafting tokens | 17029 | 12175 | **29204** | 9035 | 1308 | 462 | 314 | 1590 | 50 | 7428 | 445 | 76 | `449acd8cb` |
|
||||
| 2026-09-10 | S102 T7 s6 — the last never-attempted exemplars: 25 of 337; the fresh pool is now empty | 16996 | 12152 | **29148** | 9010 | 1283 | 462 | 314 | 1590 | 50 | 7428 | 445 | 76 | `67e91ad4d` |
|
||||
| 2026-09-10 | S102 T7 s7 (stopped early to restore agent cadence) — 5 of 207 judged at the wider width | 16989 | 12151 | **29140** | 9005 | 1280 | 462 | 314 | 1590 | 50 | 7428 | 445 | 76 | `724c68859` |
|
||||
| 2026-09-10 | S102 T7 a7 — func_801287B8: a truncated local extern was faking a pin; the missing call argument restored through a function-pointer cast (127 bodies) | 16862 | 12151 | **29013** | 8878 | 1279 | 462 | 314 | 1590 | 50 | 7428 | 445 | 76 | `bb0e95c7c` |
|
||||
|
||||
### The campaign — every batch, from the ledger (derived on every render)
|
||||
|
||||
@@ -117,7 +118,9 @@ counted, not marked). E, F and G belong to the canonical type layer and are the
|
||||
| `s5` | 2026-09-10 | G | 0 | 0 | 0 | 325 | 285 |
|
||||
| `s6` | 2026-09-10 | G | 0 | 0 | 0 | 56 | 25 |
|
||||
| `s7` | 2026-09-10 | G | 0 | 0 | 0 | 8 | 5 |
|
||||
| **total** | | | **17,119** | **20,778** | **283** | **5,107** | **3,710** |
|
||||
| `a7` | 2026-09-10 | E | 0 | 0 | 0 | 1 | 1 |
|
||||
| `a7p` | 2026-09-10 | E | 0 | 0 | 0 | 126 | 126 |
|
||||
| **total** | | | **17,119** | **20,778** | **283** | **5,234** | **3,837** |
|
||||
|
||||
*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).*
|
||||
|
||||
|
||||
@@ -1052,7 +1052,34 @@ accumulate here as the phase produces them.**
|
||||
TUs for hours, which is exactly what emptied the agent slot for six of the eight hours of S102's night; sweeps run only
|
||||
when no agent is running, and never on the live agent's TU.
|
||||
|
||||
## 🛑 SESSION CHECKPOINT — S101 (2026-09-09) / LIVE, refreshed S102 (2026-09-10): T0–T6 ☑, **T7 RUNNING — agent a1 BANKED + HARVESTED: `func_80156044` (130 bodies) and its move toolified as generator **R15, the sink**, which then closed 6 more exemplars (267 bodies) in 4 compiles each with no tokens; agent a2 banked 125 more; 30,358 → 29,572 sites, R22 218/218**; **lane B DELIVERED + 4 claims verified on bytes; lane A = rung G, `tools/delever_search.py`, BUILT, CONTROLLED, MEASURED over six runs (g1–g6b: 33,427 → 30,358 sites, 12,048 → 9,747 bodies, every bank R22 218/218, no drafting tokens); the head is where the number is (57 classes ≥100 copies = 7,318 of 9,796 residue bodies) and the wide search is spent on it; T7 APPROVED by Drew as ONE AGENT AT A TIME — the packs, the brief and the agent's scorer are built; NEXT = §2: start the serial agent loop IN THIS FRESH SESSION** | the number at this commit: **29,140 sites** (16,989 pins + 12,151 asm) in 9,005 bodies · marked 29,140 · UNMARKED 0 · orphans 0 · GTE levers 462 — `lever_census --check` OK · `lever_progress --check` OK (17 milestones). **S102's loop state: sweeps s1–s7 done or stopped; the never-attempted pool is empty. THE CADENCE IS NOW AGENTS BACK-TO-BACK (Drew, on waking: he expected dozens overnight and got three because sweeps ran between them); a sweep only in a gap, and never on the live agent's TU.**
|
||||
- **S102 — T7 agent a7: `func_801287B8` CLOSED at score 0, lever-free, 127 bodies (1 + 126 propagated, 0 refused) — and it
|
||||
is a NEW CLASS: a pin that was faking a MISSING CALL ARGUMENT.** `ov_SC04_011.c:197` declares `extern void
|
||||
func_8013BC7C(void);` while that function's real, byte-verified definition is `src/shared/ov/func_8013BC7C__8042ae05.h:3`
|
||||
— `void func_8013BC7C(void *arg0)`, dispatching through `D_8017F230[arg0->f68](arg0)`. The `$a0` instruction the pin was
|
||||
forcing is simply the argument the TU's own declaration denies. The move: a block-local `s32 *p = &D_801F1640;`, tested
|
||||
and then passed through a function-pointer cast — `((void (*)(void *))func_8013BC7C)(p);` — the idiom this TU already uses
|
||||
for two other calls. **Score 0 on the first spelling tried, where seven mechanical runs and 4,000+ compiles had sat at 3**,
|
||||
because every generator rewrites statements that are already there and this move ADDS an argument. Mechanism, both halves
|
||||
proven on bytes: `update_equiv_regs` (`local-alloc.c:947`, the "referenced exactly twice" test at `:1066`, substitution at
|
||||
`:1085-1112`) — one use folds the `SYMBOL_REF` into `lui;lw %lo`, the SECOND reference keeps the address in a register,
|
||||
which is what the `volatile` was faking; and `combine_regs` (`local-alloc.c:1722`, the hard-reg path `:1797-1818`) records
|
||||
`$4` in `qty_phys_copy_sugg[]` so `find_free_reg` (`:2073`, restricted at `:2145-2150`) colours the quantity `$4` and
|
||||
coalesces the copy away, which is what the pin was faking. Controls: reading the global directly scores 9 (63 ins), and
|
||||
declaring the pointer at function top scores 4 (`s0->a0`, an extra `move`). **Unlike a2's case this truncation is a LOCAL
|
||||
`extern`, so the cast keeps the bank body-only** — a2's was a shared header and could not be. Its generator proposal is
|
||||
**R19 "argument restore"**, a zero-compile STATIC filter: when a NEEDED pin sits on `$4`–`$7`, look up the callee's real
|
||||
arity from its shared body and offer the call with the argument restored through a cast. The agent's own method note is
|
||||
worth more than the pass reading: *an argument register in the residual's register pairs is a strong prior for "a call is
|
||||
missing an argument", and one grep answers it before any compiler source is opened.*
|
||||
`lever_census --check: 29,013 pin/asm sites, 29,013 marked !FAKE, 0 UNMARKED — OK` (29,140 → 29,013); snapshot row 18.
|
||||
- **S102 — THE BUILD-DIRECTORY HAZARD (recorded before it cost anything).** `--try` scores a candidate against the fleet
|
||||
run's BASELINE OBJECT under `build/`. The R22 gate begins with `make clean`, which deletes exactly that. **A clean fleet
|
||||
rebuild must therefore never run while agents are in flight** — every live `--try` would score against a missing or
|
||||
half-written baseline and report nonsense in the agent's own voice. Banking and propagation are safe beside agents (they
|
||||
compile into scratch and only READ `build/`), so the writing lane keeps up during a burst and the R22 fleet gate is taken
|
||||
when the burst drains, before the close.
|
||||
|
||||
## 🛑 SESSION CHECKPOINT — S101 (2026-09-09) / LIVE, refreshed S102 (2026-09-10): T0–T6 ☑, **T7 RUNNING — agent a1 BANKED + HARVESTED: `func_80156044` (130 bodies) and its move toolified as generator **R15, the sink**, which then closed 6 more exemplars (267 bodies) in 4 compiles each with no tokens; agent a2 banked 125 more; 30,358 → 29,572 sites, R22 218/218**; **lane B DELIVERED + 4 claims verified on bytes; lane A = rung G, `tools/delever_search.py`, BUILT, CONTROLLED, MEASURED over six runs (g1–g6b: 33,427 → 30,358 sites, 12,048 → 9,747 bodies, every bank R22 218/218, no drafting tokens); the head is where the number is (57 classes ≥100 copies = 7,318 of 9,796 residue bodies) and the wide search is spent on it; T7 APPROVED by Drew as ONE AGENT AT A TIME — the packs, the brief and the agent's scorer are built; NEXT = §2: start the serial agent loop IN THIS FRESH SESSION** | the number at this commit: **29,013 sites** in 8,878 bodies · marked 29,013 · UNMARKED 0 · orphans 0 — `lever_census --check` OK · `lever_progress --check` OK (18 milestones). **S102's loop state: BURST OF 20 AGENTS in flight (Drew, 2026-09-10); a7 landed and banked (127 bodies, the missing-argument class); the R22 fleet gate is DEFERRED until the burst drains because `make clean` deletes the `build/` baseline every live `--try` scores against.**
|
||||
|
||||
### 0. How to use this block
|
||||
A fresh session reads CLAUDE.md's load order, replays this block verbatim, confirms the effort (**Drew: `/effort xhigh`, Fable 5.1**
|
||||
|
||||
@@ -215,11 +215,10 @@ void func_801287B8(void) {
|
||||
func_8016E95C();
|
||||
func_801754A8();
|
||||
{
|
||||
/* D_801A5878 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded
|
||||
* lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */
|
||||
register volatile s32 *p __asm__("$4") = &D_801A5878; // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus7)
|
||||
s32 *p = &D_801A5878;
|
||||
|
||||
if (*p == 0) {
|
||||
func_8013BC7C();
|
||||
((void (*)(void *))func_8013BC7C)(p);
|
||||
}
|
||||
}
|
||||
func_8013BCDC();
|
||||
|
||||
@@ -217,11 +217,10 @@ void func_801287B8(void) {
|
||||
func_8016E95C();
|
||||
func_801754A8();
|
||||
{
|
||||
/* D_801F3158 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded
|
||||
* lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */
|
||||
register volatile s32 *p __asm__("$4") = &D_801F3158; // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus7)
|
||||
s32 *p = &D_801F3158;
|
||||
|
||||
if (*p == 0) {
|
||||
func_8013BC7C();
|
||||
((void (*)(void *))func_8013BC7C)(p);
|
||||
}
|
||||
}
|
||||
func_8013BCDC();
|
||||
|
||||
@@ -217,11 +217,10 @@ void func_801287B8(void) {
|
||||
func_8016E95C();
|
||||
func_801754A8();
|
||||
{
|
||||
/* D_80190360 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded
|
||||
* lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */
|
||||
register volatile s32 *p __asm__("$4") = &D_80190360; // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus7)
|
||||
s32 *p = &D_80190360;
|
||||
|
||||
if (*p == 0) {
|
||||
func_8013BC7C();
|
||||
((void (*)(void *))func_8013BC7C)(p);
|
||||
}
|
||||
}
|
||||
func_8013BCDC();
|
||||
|
||||
@@ -217,11 +217,10 @@ void func_801287B8(void) {
|
||||
func_8016E95C();
|
||||
func_801754A8();
|
||||
{
|
||||
/* D_801CDFC0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded
|
||||
* lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */
|
||||
register volatile s32 *p __asm__("$4") = &D_801CDFC0; // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus7)
|
||||
s32 *p = &D_801CDFC0;
|
||||
|
||||
if (*p == 0) {
|
||||
func_8013BC7C();
|
||||
((void (*)(void *))func_8013BC7C)(p);
|
||||
}
|
||||
}
|
||||
func_8013BCDC();
|
||||
|
||||
@@ -217,11 +217,10 @@ void func_801287B8(void) {
|
||||
func_8016E95C();
|
||||
func_801754A8();
|
||||
{
|
||||
/* D_801A3570 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded
|
||||
* lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */
|
||||
register volatile s32 *p __asm__("$4") = &D_801A3570; // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus7)
|
||||
s32 *p = &D_801A3570;
|
||||
|
||||
if (*p == 0) {
|
||||
func_8013BC7C();
|
||||
((void (*)(void *))func_8013BC7C)(p);
|
||||
}
|
||||
}
|
||||
func_8013BCDC();
|
||||
|
||||
@@ -217,11 +217,10 @@ void func_801287B8(void) {
|
||||
func_8016E95C();
|
||||
func_801754A8();
|
||||
{
|
||||
/* D_801F33F0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded
|
||||
* lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */
|
||||
register volatile s32 *p __asm__("$4") = &D_801F33F0; // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus7)
|
||||
s32 *p = &D_801F33F0;
|
||||
|
||||
if (*p == 0) {
|
||||
func_8013BC7C();
|
||||
((void (*)(void *))func_8013BC7C)(p);
|
||||
}
|
||||
}
|
||||
func_8013BCDC();
|
||||
|
||||
@@ -217,11 +217,10 @@ void func_801287B8(void) {
|
||||
func_8016E95C();
|
||||
func_801754A8();
|
||||
{
|
||||
/* D_8019BD00 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded
|
||||
* lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */
|
||||
register volatile s32 *p __asm__("$4") = &D_8019BD00; // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus7)
|
||||
s32 *p = &D_8019BD00;
|
||||
|
||||
if (*p == 0) {
|
||||
func_8013BC7C();
|
||||
((void (*)(void *))func_8013BC7C)(p);
|
||||
}
|
||||
}
|
||||
func_8013BCDC();
|
||||
|
||||
@@ -258,11 +258,10 @@ void func_801287B8(void) {
|
||||
func_8016E95C();
|
||||
func_801754A8();
|
||||
{
|
||||
/* D_801DAAC0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded
|
||||
* lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */
|
||||
register volatile s32 *p __asm__("$4") = &D_801DAAC0; // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus7)
|
||||
s32 *p = &D_801DAAC0;
|
||||
|
||||
if (*p == 0) {
|
||||
func_8013BC7C();
|
||||
((void (*)(void *))func_8013BC7C)(p);
|
||||
}
|
||||
}
|
||||
func_8013BCDC();
|
||||
|
||||
@@ -217,11 +217,10 @@ void func_801287B8(void) {
|
||||
func_8016E95C();
|
||||
func_801754A8();
|
||||
{
|
||||
/* D_801C7EE0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded
|
||||
* lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */
|
||||
register volatile s32 *p __asm__("$4") = &D_801C7EE0; // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus7)
|
||||
s32 *p = &D_801C7EE0;
|
||||
|
||||
if (*p == 0) {
|
||||
func_8013BC7C();
|
||||
((void (*)(void *))func_8013BC7C)(p);
|
||||
}
|
||||
}
|
||||
func_8013BCDC();
|
||||
|
||||
@@ -217,11 +217,10 @@ void func_801287B8(void) {
|
||||
func_8016E95C();
|
||||
func_801754A8();
|
||||
{
|
||||
/* D_801C7B88 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded
|
||||
* lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */
|
||||
register volatile s32 *p __asm__("$4") = &D_801C7B88; // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus7)
|
||||
s32 *p = &D_801C7B88;
|
||||
|
||||
if (*p == 0) {
|
||||
func_8013BC7C();
|
||||
((void (*)(void *))func_8013BC7C)(p);
|
||||
}
|
||||
}
|
||||
func_8013BCDC();
|
||||
|
||||
@@ -217,11 +217,10 @@ void func_801287B8(void) {
|
||||
func_8016E95C();
|
||||
func_801754A8();
|
||||
{
|
||||
/* D_801E87C0 read: the target materializes &sym into $a0 then lw 0($a0) (not the folded
|
||||
* lui;lw %lo). volatile forces the rematerialize; the $4 pin forces the a0 allocation. */
|
||||
register volatile s32 *p __asm__("$4") = &D_801E87C0; // !FAKE: pin $4 — NEEDED DIFFERS (P36 rung B tus7)
|
||||
s32 *p = &D_801E87C0;
|
||||
|
||||
if (*p == 0) {
|
||||
func_8013BC7C();
|
||||
((void (*)(void *))func_8013BC7C)(p);
|
||||
}
|
||||
}
|
||||
func_8013BCDC();
|
||||
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user