phase12: match func_800376CC (690 bodies / 699 regions)

config/regions.tsv

@@ -204,6 +204,7 @@
 0x80036DA4	0x80036F70	src/func_80036DA4.c
 0x80036F70	0x8003713C	src/func_80036F70.c
 0x8003768C	0x800376CC	src/func_8003768C.c
+0x800376CC	0x80037770	src/func_800376CC.c
 0x80038788	0x80038790	src/func_80038788.c
 0x80038790	0x8003879C	src/func_80038790.c
 0x80038D48	0x80038DD8	src/func_80038D48.c

phase-ends/CURRENT_PHASE.md

@@ -6,18 +6,18 @@
 
 ## STATE — SOLO CONTINUATION, 2026-09-24 (current)
 
-**689 bodies / 698 regions**, from 685 / 694 at the last session stop — **+4 bodies / +4 regions**.
-The Phase 12 milestone remains 750 bodies, so **+61 remains**. The promoted whole-binary gate is green:
-`c_regions=698`, `differing_bytes=0`, SHA-1
+**690 bodies / 699 regions**, from 685 / 694 at the last session stop — **+5 bodies / +5 regions**.
+The Phase 12 milestone remains 750 bodies, so **+60 remains**. The promoted whole-binary gate is green:
+`c_regions=699`, `differing_bytes=0`, SHA-1
 `e173426c157384ebf1b6caf8c6fea18a85a14af9`; 344 synthetic tests pass and extents report
-`regions=698 disagreements=0 result=AGREE`.
+`regions=699 disagreements=0 result=AGREE`.
 
-Tasks 1–4/10 completed `0x80102F58` (60 bytes, plus three proven gp symbol rows), `0x80027BE8`
-(92 bytes, first spelling), `0x8006BB88` (128 bytes), and `0x8008A400` (124 bytes). The third required
-two byte-required GNU C register bindings and a source-order flip; the fourth preserves the intermediate
-`Q*` at `R+12` and orders local loads x/y/z before negating y. Worklist regeneration is now 982 rows;
-`excluded_already_registered=696` continues the already-characterised two-row registry lag and is not a
-correctness issue because the 698-region gate proves the registry simultaneously.
+Tasks 1–5/10 completed `0x80102F58` (60 bytes, plus three proven gp symbol rows), `0x80027BE8`
+(92 bytes, first spelling), `0x8006BB88` (128 bytes), `0x8008A400` (124 bytes), and `0x800376CC`
+(164 bytes). The fifth closes the prior named-equality residual by binding the chain result to t0 and
+copying it to a v0-bound second reader before the branch. Worklist regeneration is now 981 rows;
+`excluded_already_registered=697` continues the already-characterised two-row registry lag and is not a
+correctness issue because the 699-region gate proves the registry simultaneously.
 
 ## STATE — SESSION STOP, 2026-09-24 23:35 (historical; superseded by the state above, kept for provenance)
 

phase-ends/logs/Phase12.md

@@ -1925,3 +1925,20 @@ under `.run/p12/solo/`.
   `excluded_already_registered=696`, preserving the known two-row lag.
 
 **Count after task 4: 689 bodies / 698 regions (+87 bodies from the Phase 12 open baseline).**
+
+### Task 5/10 — `0x800376CC` (164 B) MATCH
+
+* Exact extent: `0x800376CC..0x80037770`, 164 bytes, grade `exact`, no duplicate group.
+* Reused the prior structurally derived list-search source and its 160-byte receipt. The missing
+  instruction was not a new algorithm: the original materializes the equality-chain result in t0,
+  copies it to v0, and branches on v0. Binding `eq` to `$8` and a second `test` reader to `$2`, then
+  writing `test = eq` before the test, produces the required copy without an extra call.
+* Tracked source md5: `5ae49557a3c783d8921fd3c2cbffa8c6`. Fresh tracked range: 164 bytes,
+  `differing_bytes=0 result=MATCH`.
+* `sf3_merge` accepted the claim. Candidate whole-binary gate: 699 regions, 0 differing bytes, both
+  SHA-1 values `e173426c157384ebf1b6caf8c6fea18a85a14af9`, exit 0.
+* Promoted `make check`: 344 tests OK; extents `regions=699 disagreements=0`; gate
+  `c_regions=699 differing_bytes=0 result=MATCH`. Worklist is now 981 rows and reports
+  `excluded_already_registered=697`, preserving the known two-row lag.
+
+**Count after task 5: 690 bodies / 699 regions (+88 bodies from the Phase 12 open baseline).**

src/func_800376CC.c

@@ -0,0 +1,66 @@
+/*
+ * func_800376CC — 164 bytes at 0x800376CC..0x80037770
+ *
+ * Searches a singly linked list whose head is at +5356 in the first argument. A null
+ * second argument together with a null fourth argument returns zero immediately. For
+ * each node, the first word is compared with the third argument; when that argument is
+ * null, the record fields at +24/+28/+32 are compared with the second argument's fields
+ * at +20/+24/+28. A matching node is returned, otherwise the node's +8 link is followed.
+ *
+ * The equality chain is assigned to an `eq` value and then copied to a second local
+ * before the test. The GNU C register bindings are byte-required: the original keeps the
+ * chain result in t0, copies it to v0, and branches on v0. Without the second reader,
+ * cc1 coalesces the two pseudos and emits 160 bytes. The bindings reproduce the original's
+ * `move v0,t0` without adding a call or changing the search semantics.
+ *
+ * LIMITS: Node/record field names and the meaning of the context at +5356 are hypotheses;
+ * the pointer offsets, field comparisons, control-flow exits, and return values are the
+ * evidence used for this reconstruction.
+ */
+
+typedef struct Rec {
+    int f0;
+    int f4;
+    int f8;
+    int f12;
+    int f16;
+    int f20;
+    int f24;
+    int f28;
+    int f32;
+} Rec;
+
+typedef struct Node {
+    Rec *rec;
+    int f4;
+    struct Node *next;
+} Node;
+
+typedef struct Ctx {
+    char pad[5356];
+    Node *head;
+} Ctx;
+
+Node *func_800376CC(Ctx *c, int a1, Rec *a2, int a3)
+{
+    Node *n = c->head;
+    register int eq __asm__("$8");
+    register int test __asm__("$2");
+
+    if (a2 == 0 && a3 == 0)
+        return 0;
+
+    for (; n != 0; n = n->next) {
+        Rec *r = n->rec;
+        if (r == (Rec *)a3)
+            return n;
+        if (a3 == 0 && r->f0 == a1) {
+            eq = (r->f24 == a2->f20) && (r->f28 == a2->f24) &&
+                 (r->f32 == a2->f28);
+            test = eq;
+            if (test != 0)
+                return n;
+        }
+    }
+    return n;
+}