phase12: match func_80039308 (737 bodies / 746 regions)

config/match_worklist.tsv

@@ -959,7 +959,7 @@
 952	0x801007E0	0x80100808	40	fallthrough	3	frame	1	-	1
 #
 # listed=952
-# excluded_already_registered=743
+# excluded_already_registered=744
 # excluded_bad_extent_start=8
 # excluded_degenerate_body=252
 # excluded_delay_slot_start=5
@@ -968,6 +968,6 @@
 # excluded_low_confidence_grade=90
 # excluded_named_exclusion=9
 # excluded_no_extent=0
-# excluded_recorded_negative=85
+# excluded_recorded_negative=84
 # excluded_restores_unsaved=11
 # excluded_trapping_arith=48

config/regions.tsv

@@ -217,6 +217,7 @@
 0x80038788	0x80038790	src/func_80038788.c
 0x80038790	0x8003879C	src/func_80038790.c
 0x80038D48	0x80038DD8	src/func_80038D48.c
+0x80039308	0x80039354	src/func_80039308.c
 0x8003A5F4	0x8003A644	src/func_8003A5F4.c
 0x8003A644	0x8003A6E0	src/func_8003A644.c
 0x8003A9C8	0x8003AAB8	src/func_8003A9C8.c

phase-ends/CURRENT_PHASE.md

@@ -6,11 +6,11 @@
 
 ## STATE — SOLO CONTINUATION, 2026-09-24 (current)
 
-**736 bodies / 745 regions**, from 685 / 694 at the last session stop — **+51 bodies / +51 regions**.
-The Phase 12 milestone remains 750 bodies, so **+14 remains**. The promoted whole-binary gate is green:
-`c_regions=745`, `differing_bytes=0`, SHA-1
+**737 bodies / 746 regions**, from 685 / 694 at the last session stop — **+52 bodies / +52 regions**.
+The Phase 12 milestone remains 750 bodies, so **+13 remains**. The promoted whole-binary gate is green:
+`c_regions=746`, `differing_bytes=0`, SHA-1
 `e173426c157384ebf1b6caf8c6fea18a85a14af9`; 348 synthetic tests pass and extents report
-`regions=745 disagreements=0 result=AGREE`.
+`regions=746 disagreements=0 result=AGREE`.
 
 The requested second batch of 20 is complete. Twenty additional bodies are now matched:
 `0x800BC9C4`, `0x800BC8C4`, `0x8006BB0C`, `0x8002D17C`, `0x801029A0`, `0x80055958`,
@@ -24,7 +24,7 @@ Final clean verification (2026-09-25): `make clean && make all`, `make worklist`
 `make extents-verify`, and `make check` all exited 0. Both clean assembly and code rebuilds
 matched the USA executable byte-for-byte; each is 1,886,208 bytes with SHA-1
 `e173426c157384ebf1b6caf8c6fea18a85a14af9`. The final worklist is 952 rows and the extents
-check reports `regions=745 disagreements=0 result=AGREE`.
+check reports `regions=746 disagreements=0 result=AGREE`.
 ## STATE — SESSION STOP, 2026-09-24 23:35 (historical; superseded by the state above, kept for provenance)
 
 **685 bodies / 694 regions**, from 602 / 611 at the Phase 11 close — **+83 bodies**. **Milestone 750 was NOT

phase-ends/logs/Phase12.md

@@ -2565,6 +2565,17 @@ passed with 348 tests and extents `regions=742 disagreements=0`; worklist regene
 **Count after task 39: 736 bodies / 745 regions (+134 bodies from the Phase 12 open baseline;
 +14 remain to milestone 750).**
 
+### Worker C task 40 — `0x80039308` MATCH
+
+* Exact extent `0x80039308..0x80039354`, 76 bytes, default toolchain.
+* The six-byte record copy is three explicit unsigned-short member assignments, not a struct
+  assignment; the latter becomes an unaligned block move with `lwl/lwr/swl/swr`.
+* Fresh range and candidate whole-binary gate passed with zero differences; `make check` passed with
+  348 tests and extents `regions=746 disagreements=0`; worklist remains 952 rows.
+
+**Count after task 40: 737 bodies / 746 regions (+135 bodies from the Phase 12 open baseline;
++13 remain to milestone 750).**
+
 ### Duplicate-claim guard incident
 
 A later autonomous draft attempted `0x8006FAEC`, but the merge check showed that exact region was

src/func_80039308.c

@@ -0,0 +1,69 @@
+/*
+ * func_80039308 — 76 bytes at 0x80039308..0x80039354
+ *
+ * PHASE 12 RESUME LANE C (autonomous matching). Row from the UN-ATTEMPTED band
+ * (negatives-d-unattempted.tsv) filtered through config/function_extents.tsv
+ * (size 76 grade exact term=jr_ra). NOT previously in the ledger.
+ *
+ * MATCH: candidate_bytes=76, differing_bytes=0, result=MATCH, exit 0 on the DEFAULT toolchain
+ * (tools/old-gcc/gcc-2.7.2-psx/cc1). No region overrides.
+ *
+ * Hypothesis, not a claim about meaning: copy the six-byte record at the front of an array of
+ * eight-byte slots over every later slot, for slots 1 up to (but excluding) `a1`.
+ *
+ * Original words (19):
+ *     24060001  li    a2,1              i = 1
+ *     00C5102A  slt   v0,a2,a1          v0 = (i < a1)
+ *     1040000E  beqz  v0,0x8003934c     if (!(i < a1)) -> the exit
+ *     00000000  nop
+ * $L: 24830008  addiu v1,a0,8          v1 = &a0[1]  (the induction pointer, stride 8)
+ *     94820000  lhu   v0,0(a0)          ---- the source record, read through a0 every time ----
+ *     00000000  nop
+ *     A4620000  sh    v0,0(v1)
+ *     94820002  lhu   v0,2(a0)
+ *     00000000  nop
+ *     A4620002  sh    v0,2(v1)
+ *     94820004  lhu   v0,4(a0)
+ *     24C60001  addiu a2,a2,1           i++  (scheduled into the middle of the copy)
+ *     A4620004  sh    v0,4(v1)
+ *     00C5102A  slt   v0,a2,a1
+ *     1440FFF5  bnez  v0,0x8003931c     the rotated bottom test
+ *     24630008  addiu v1,v1,8           (delay slot) v1 += 8
+ *     03E00008  jr    ra
+ *     00000000  nop
+ *
+ * THE LEVER: THE STRUCT COPY MUST BE WRITTEN AS THREE MEMBER ASSIGNMENTS.
+ * `a0[i].r = a0[0].r;` (one six-byte struct assignment) is 72 bytes and compiles the copy as an
+ * UNALIGNED BLOCK MOVE -- `lwl v0,3(t0) / lwr v0,0(t0) / lh v1,4(t0)` then
+ * `swl v0,3(a3) / swr v0,0(a3) / sh v1,4(a3)` -- which is four bytes SHORT and visibly different
+ * (lwl/lwr/swl/swr are not in the original at all). Writing the three members out
+ *     a0[i].r.a = a0[0].r.a;  a0[i].r.b = a0[0].r.b;  a0[i].r.c = a0[0].r.c;
+ * gives the original's three `lhu`/`sh` pairs exactly. The halfword loads are `lhu`
+ * (UNSIGNED), so the record's fields are `unsigned short`; a signed `short` would emit `lh`.
+ *
+ * LIMITS: the 8-byte slot with a 6-byte payload (a 2-byte pad after the record) is read off the
+ * address arithmetic (`addiu v1,a0,8` and the +8 stride) with no independent evidence; the pad is
+ * never touched. What the copy is FOR is not recoverable from this body.
+ */
+
+struct Rec {
+    unsigned short a;
+    unsigned short b;
+    unsigned short c;
+};
+
+struct Slot {
+    struct Rec r;
+    unsigned short pad;
+};
+
+void func_80039308(struct Slot *a0, int a1)
+{
+    int i;
+
+    for (i = 1; i < a1; i++) {
+        a0[i].r.a = a0[0].r.a;
+        a0[i].r.b = a0[0].r.b;
+        a0[i].r.c = a0[0].r.c;
+    }
+}