test: own the 926/929/671 run legs as corpus fixtures

The three carriers retired this session moved their compile/byte-id/
asm-marker legs to test/asm/tagsret_test.ww, test/asm/memarg_test.ww,
and test/misc/packedwwi_test.ww, and audit-assigned their run-exit
legs to corpus fixtures that were never created. Create them, sources
byte-faithful to the carriers' row tables; every fixture also rides
the corpus byte-id sweep, which stayed green (no new DATABYTEID pin).

926_tagged_sret_run.c run rows (all exit 0):
  wide_lit_roundtrip          -> r926_sret_wide_lit_roundtrip
  wide_local_roundtrip        -> r926_sret_wide_local_roundtrip
  wide_assign_receive         -> r926_sret_wide_assign_receive
  wide_match_scrutinee        -> r926_sret_wide_match_scrutinee
  wide_forward_exact          -> r926_sret_wide_forward_exact
  wide_str_error_variant      -> r926_sret_wide_str_error_variant
  wide_multicall              -> r926_sret_wide_multicall
  wide_bare_return_void       -> r926_sret_wide_bare_return_void
  wide_s4_repro               -> r926_sret_wide_s4_repro
  errno_shaped_tail_read      -> r926_sret_errno_shaped_tail_read
  boundary_s3_register        -> r926_sret_boundary_s3_register
  boundary_str_nomem_register -> r926_sret_boundary_str_nomem_register
  wide_discard_stmt           -> r926_sret_wide_discard_stmt
(the seven buildfail rows stay with r926_sret_reject_*.)

929_tagged_memarg_run.c run rows (exit 0 unless noted):
  mem56_ident_allvariants  -> r929_memarg_mem56_ident_allvariants
  mem64_ident_lateword     -> r929_memarg_mem64_ident_lateword
  mem56_widen_concrete     -> r929_memarg_mem56_widen_concrete
  mem56_subset_remap       -> r929_memarg_mem56_subset_remap
  mem56_srcshapes          -> r929_memarg_mem56_srcshapes
  mem56_mixed_orders       -> r929_memarg_mem56_mixed_orders
  mem56_call_in_loop       -> r929_memarg_mem56_call_in_loop
  mem56_twomem             -> r929_memarg_mem56_twomem
  mem56_inst_shape         -> r929_memarg_mem56_inst_shape
  mem56_elem_source        -> r929_memarg_mem56_elem_source
  mem56_elem_deref_spine   -> r929_memarg_mem56_elem_deref_spine
  mem56_elem_nested_spine  -> r929_memarg_mem56_elem_nested_spine
  mem56_elem_mixed_regs    -> r929_memarg_mem56_elem_mixed_regs
  mem56_elem_callidx_twomem -> r929_memarg_mem56_elem_callidx_twomem
  mem56_elem_global_slice  -> r929_memarg_mem56_elem_global_slice
  boundary48_register      -> r929_memarg_boundary48_register
  global_uninit_memarg_src -> r929_memarg_global_uninit_memarg_src (91)
  memarg_idcast_peeled     -> r929_memarg_idcast_peeled
(the four buildfail rows stay with r929_memarg_reject_*.)

671_struct_packed.c value rows (exit = layout value):
  unpacked_size    -> r671_unpacked_size (16)
  packed_size      -> r671_packed_size (9)
  packed_off_b     -> r671_packed_off_b (1)
  unpacked_off_b   -> r671_unpacked_off_b (8)
  packed_align     -> r671_packed_align (8)
  packed5_size     -> r671_packed5_size (5)
  packed5_off_b    -> r671_packed5_off_b (1)
  p3_packed_size   -> r671_p3_packed_size (4)
  p3_packed_off_c  -> r671_p3_packed_off_c (3)
  p3_unpacked_size -> r671_p3_unpacked_size (6)
  field_roundtrip  -> r671_field_roundtrip (6)
  arr_stride_size  -> r671_arr_stride_size (15)
  arr_stride_run   -> r671_arr_stride_run (33)
  byval_arg        -> r671_byval_arg (107)
  frame_offset     -> r671_frame_offset (20)
Owner-cited, no fixture: wwi_roundtrip needs a real multi-file -I
tree (a single-file two-package form emits no .wwi), owned by
test/misc/packedwwi_test.ww wwiroundtrip (exit 91 on both drivers);
identity_reject is stage-asymmetric, owned there as identityreject.

Pins: corpuscount 1680 -> 1726, runexitcount 1109 -> 1155,
nativecount 3360 -> 3452, corpushash refreshed.

internal/wwfixture/types.ww

@@ -1,13 +1,13 @@
 package wwfixture;
 
 def protocolversion: i32 = 1;
-def corpuscount: i32 = 1680;
+def corpuscount: i32 = 1726;
 def errorcount: i32 = 343;
 def compilecount: i32 = 19;
 def runcount: i32 = 209;
-def runexitcount: i32 = 1109;
-def nativecount: i32 = 3360;
-def corpushash: str = "bfc1df1f29f60a79930227b1b93ad01fcbed23a150c3269f1f6befd90e0604d1";
+def runexitcount: i32 = 1155;
+def nativecount: i32 = 3452;
+def corpushash: str = "870ba4f5140ef331e9effb7cf21fcebe69b5f29d1177cf158e6a1b6db71e9d28";
 
 type directive = enum i32 {
 	ERROR = 0,

test/wcc/data/r671_arr_stride_run/case.ww

@@ -0,0 +1,9 @@
+//ww:run-exit 33
+// Run leg of the retired 671_struct_packed.c row arr_stride_run.
+package main;
+type P = struct @packed { a: u8, b: u32 };
+export fn main() i32 = {
+	let t: [3]P;
+	t[0].b = 11u32; t[1].b = 22u32; t[2].b = 33u32;
+	return t[2].b: i32;
+};

test/wcc/data/r671_arr_stride_size/case.ww

@@ -0,0 +1,5 @@
+//ww:run-exit 15
+// Run leg of the retired 671_struct_packed.c row arr_stride_size.
+package main;
+type P = struct @packed { a: u8, b: u32 };
+export fn main() i32 = { return size([3]P): i32; };

test/wcc/data/r671_byval_arg/case.ww

@@ -0,0 +1,9 @@
+//ww:run-exit 107
+// Run leg of the retired 671_struct_packed.c row byval_arg.
+package main;
+type Q = struct @packed { a: u8, b: u32 };
+fn useq(q: Q) i32 = { return (q.a: i32) + (q.b: i32); };
+export fn main() i32 = {
+	let q: Q = Q { a = 7u8, b = 100u32 };
+	return useq(q);
+};

test/wcc/data/r671_field_roundtrip/case.ww

@@ -0,0 +1,8 @@
+//ww:run-exit 6
+// Run leg of the retired 671_struct_packed.c row field_roundtrip.
+package main;
+type P = struct @packed { a: u8, b: u16, c: u8 };
+export fn main() i32 = {
+	let p: P = P { a = 1u8, b = 2u16, c = 3u8 };
+	return (p.a: i32) + (p.b: i32) + (p.c: i32);
+};

test/wcc/data/r671_frame_offset/case.ww

@@ -0,0 +1,10 @@
+//ww:run-exit 20
+// Run leg of the retired 671_struct_packed.c row frame_offset.
+package main;
+type Q = struct @packed { a: u8, b: u32 };
+export fn main() i32 = {
+	let p: Q = Q { a = 1u8, b = 5u32 };
+	let after: i32 = 77;
+	p.b = 200u32;
+	return (p.b: i32) + after - (p.a: i32);
+};

test/wcc/data/r671_p3_packed_off_c/case.ww

@@ -0,0 +1,8 @@
+//ww:run-exit 3
+// Run leg of the retired 671_struct_packed.c row p3_packed_off_c.
+package main;
+type P = struct @packed { a: u8, b: u16, c: u8 };
+export fn main() i32 = {
+	let p: P = P { a = 1u8, b = 2u16, c = 3u8 };
+	return offset(p.c): i32;
+};

test/wcc/data/r671_p3_packed_size/case.ww

@@ -0,0 +1,5 @@
+//ww:run-exit 4
+// Run leg of the retired 671_struct_packed.c row p3_packed_size.
+package main;
+type P = struct @packed { a: u8, b: u16, c: u8 };
+export fn main() i32 = { return size(P): i32; };

test/wcc/data/r671_p3_unpacked_size/case.ww

@@ -0,0 +1,5 @@
+//ww:run-exit 6
+// Run leg of the retired 671_struct_packed.c row p3_unpacked_size.
+package main;
+type U = struct { a: u8, b: u16, c: u8 };
+export fn main() i32 = { return size(U): i32; };

test/wcc/data/r671_packed5_off_b/case.ww

@@ -0,0 +1,8 @@
+//ww:run-exit 1
+// Run leg of the retired 671_struct_packed.c row packed5_off_b.
+package main;
+type P = struct @packed { a: u8, b: u32 };
+export fn main() i32 = {
+	let p: P = P { a = 1u8, b = 2u32 };
+	return offset(p.b): i32;
+};

test/wcc/data/r671_packed5_size/case.ww

@@ -0,0 +1,5 @@
+//ww:run-exit 5
+// Run leg of the retired 671_struct_packed.c row packed5_size.
+package main;
+type P = struct @packed { a: u8, b: u32 };
+export fn main() i32 = { return size(P): i32; };

test/wcc/data/r671_packed_align/case.ww

@@ -0,0 +1,5 @@
+//ww:run-exit 8
+// Run leg of the retired 671_struct_packed.c row packed_align.
+package main;
+type P = struct @packed { a: u8, b: u64 };
+export fn main() i32 = { return align(P): i32; };

test/wcc/data/r671_packed_off_b/case.ww

@@ -0,0 +1,8 @@
+//ww:run-exit 1
+// Run leg of the retired 671_struct_packed.c row packed_off_b.
+package main;
+type P = struct @packed { a: u8, b: u64 };
+export fn main() i32 = {
+	let p: P = P { a = 1u8, b = 2u64 };
+	return offset(p.b): i32;
+};

test/wcc/data/r671_packed_size/case.ww

@@ -0,0 +1,5 @@
+//ww:run-exit 9
+// Run leg of the retired 671_struct_packed.c row packed_size.
+package main;
+type P = struct @packed { a: u8, b: u64 };
+export fn main() i32 = { return size(P): i32; };

test/wcc/data/r671_unpacked_off_b/case.ww

@@ -0,0 +1,8 @@
+//ww:run-exit 8
+// Run leg of the retired 671_struct_packed.c row unpacked_off_b.
+package main;
+type U = struct { a: u8, b: u64 };
+export fn main() i32 = {
+	let u: U = U { a = 1u8, b = 2u64 };
+	return offset(u.b): i32;
+};

test/wcc/data/r671_unpacked_size/case.ww

@@ -0,0 +1,5 @@
+//ww:run-exit 16
+// Run leg of the retired 671_struct_packed.c row unpacked_size.
+package main;
+type U = struct { a: u8, b: u64 };
+export fn main() i32 = { return size(U): i32; };

test/wcc/data/r926_sret_boundary_s3_register/case.ww

@@ -0,0 +1,19 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row boundary_s3_register.
+package main;
+type s3 = struct { a: i64, b: i64, c: i64 };
+fn mk(ok: bool) (s3 | bool) = {
+	if (!ok) { return false; };
+	return s3 { a = 7, b = 8, c = 9 };
+};
+export fn main() i32 = {
+	match (mk(true)) {
+	case let v: s3 => { if (v.c != 9) { return 1; }; };
+	case let b: bool => return 2;
+	};
+	match (mk(false)) {
+	case let v: s3 => return 3;
+	case let b: bool => { if (b) { return 4; }; };
+	};
+	return 0;
+};

test/wcc/data/r926_sret_boundary_str_nomem_register/case.ww

@@ -0,0 +1,20 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row boundary_str_nomem_register.
+package main;
+type nomem = !void;
+fn pick(ok: bool) (str | nomem) = {
+	if (ok) { return "hello"; };
+	let nm: nomem;
+	return nm;
+};
+export fn main() i32 = {
+	match (pick(true)) {
+	case let s: str => { if (s.len != 5) { return 1; }; };
+	case nomem => return 2;
+	};
+	match (pick(false)) {
+	case let s: str => return 3;
+	case nomem => { };
+	};
+	return 0;
+};

test/wcc/data/r926_sret_errno_shaped_tail_read/case.ww

@@ -0,0 +1,24 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row errno_shaped_tail_read.
+package main;
+type opq = struct { h: i64, data: [3]u64 };
+fn wrap(e: i64) (opq | bool) = {
+	let o: opq;
+	o.h = 7;
+	o.data[0] = e: u64;
+	o.data[1] = 1111u64;
+	o.data[2] = 2222u64;
+	return o;
+};
+export fn main() i32 = {
+	match (wrap(5)) {
+	case let o: opq => {
+		if (o.data[2] != 2222u64) { return 1; };
+		if (o.data[1] != 1111u64) { return 2; };
+		if (o.data[0] != 5u64) { return 3; };
+		if (o.h != 7) { return 4; };
+	};
+	case let b: bool => return 5;
+	};
+	return 0;
+};

test/wcc/data/r926_sret_wide_assign_receive/case.ww

@@ -0,0 +1,24 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row wide_assign_receive.
+package main;
+type oops = !str;
+type nomem = !void;
+type wide = struct { xs: []u8, ys: []u8, n: i64 };
+fn mk(b: []u8, n: i64) (wide | oops | nomem) = {
+	return wide { xs = b, ys = b, n = n };
+};
+export fn main() i32 = {
+	let canary1: i64 = 111;
+	let buf: [4]u8 = [1u8, 2u8, 3u8, 4u8];
+	let r: (wide | oops | nomem) = mk(buf[0:4], 5);
+	let canary2: i64 = 222;
+	r = mk(buf[0:4], 6);
+	if (canary1 != 111) { return 21; };
+	if (canary2 != 222) { return 22; };
+	match (r) {
+	case let w: wide => { if (w.n != 6) { return 1; }; };
+	case let e: oops => return 13;
+	case nomem => return 14;
+	};
+	return 0;
+};

test/wcc/data/r926_sret_wide_bare_return_void/case.ww

@@ -0,0 +1,19 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row wide_bare_return_void.
+package main;
+type s4 = struct { a: i64, b: i64, c: i64, d: i64 };
+fn maybe(n: i64) (s4 | void) = {
+	if (n == 0) { return; };
+	return s4 { a = 1, b = 2, c = 3, d = n };
+};
+export fn main() i32 = {
+	match (maybe(0)) {
+	case let v: s4 => return 1;
+	case void => { };
+	};
+	match (maybe(5)) {
+	case let v: s4 => { if (v.d != 5) { return 2; }; };
+	case void => return 3;
+	};
+	return 0;
+};

test/wcc/data/r926_sret_wide_discard_stmt/case.ww

@@ -0,0 +1,17 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row wide_discard_stmt.
+package main;
+type oops = !str;
+type nomem = !void;
+type wide = struct { xs: []u8, ys: []u8, n: i64 };
+fn mk(b: []u8) (wide | oops | nomem) = {
+	return wide { xs = b, ys = b, n = 1 };
+};
+export fn main() i32 = {
+	let canary: i64 = 777;
+	let buf: [4]u8 = [1u8, 2u8, 3u8, 4u8];
+	mk(buf[0:4]);
+	mk(buf[0:4]);
+	if (canary != 777) { return 1; };
+	return 0;
+};

test/wcc/data/r926_sret_wide_forward_exact/case.ww

@@ -0,0 +1,21 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row wide_forward_exact.
+package main;
+type oops = !str;
+type nomem = !void;
+type wide = struct { xs: []u8, ys: []u8, n: i64 };
+fn inner(b: []u8, n: i64) (wide | oops | nomem) = {
+	return wide { xs = b, ys = b, n = n };
+};
+fn outer(b: []u8, n: i64) (wide | oops | nomem) = {
+	return inner(b, n);
+};
+export fn main() i32 = {
+	let buf: [4]u8 = [1u8, 2u8, 3u8, 4u8];
+	match (outer(buf[0:4], 11)) {
+	case let w: wide => { if (w.n != 11) { return 1; }; };
+	case let e: oops => return 13;
+	case nomem => return 14;
+	};
+	return 0;
+};

test/wcc/data/r926_sret_wide_lit_roundtrip/case.ww

@@ -0,0 +1,23 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row wide_lit_roundtrip.
+package main;
+type oops = !str;
+type nomem = !void;
+type wide = struct { xs: []u8, ys: []u8, n: i64 };
+fn mk(b: []u8, n: i64) (wide | oops | nomem) = {
+	return wide { xs = b, ys = b, n = n };
+};
+export fn main() i32 = {
+	let buf: [4]u8 = [9u8, 8u8, 7u8, 6u8];
+	match (mk(buf[0:4], 42)) {
+	case let w: wide => {
+		if (w.n != 42) { return 1; };
+		if (w.xs.len != 4) { return 2; };
+		if (w.ys.len != 4) { return 3; };
+		if (w.xs[3] != 6u8) { return 4; };
+	};
+	case let e: oops => return 13;
+	case nomem => return 14;
+	};
+	return 0;
+};

test/wcc/data/r926_sret_wide_local_roundtrip/case.ww

@@ -0,0 +1,23 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row wide_local_roundtrip.
+package main;
+type oops = !str;
+type nomem = !void;
+type wide = struct { xs: []u8, ys: []u8, n: i64 };
+fn mk(b: []u8, n: i64) (wide | oops | nomem) = {
+	let w: wide = wide { xs = b, ys = b, n = n };
+	return w;
+};
+export fn main() i32 = {
+	let buf: [4]u8 = [1u8, 2u8, 3u8, 4u8];
+	let r: (wide | oops | nomem) = mk(buf[0:4], 7);
+	match (r) {
+	case let w: wide => {
+		if (w.n != 7) { return 1; };
+		if (w.ys[0] != 1u8) { return 2; };
+	};
+	case let e: oops => return 13;
+	case nomem => return 14;
+	};
+	return 0;
+};

test/wcc/data/r926_sret_wide_match_scrutinee/case.ww

@@ -0,0 +1,18 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row wide_match_scrutinee.
+package main;
+type oops = !str;
+type nomem = !void;
+type wide = struct { xs: []u8, ys: []u8, n: i64 };
+fn mk(b: []u8, n: i64) (wide | oops | nomem) = {
+	return wide { xs = b, ys = b, n = n };
+};
+export fn main() i32 = {
+	let buf: [4]u8 = [1u8, 2u8, 3u8, 4u8];
+	match (mk(buf[0:4], 9)) {
+	case let w: wide => { if (w.n != 9) { return 1; }; };
+	case let e: oops => return 13;
+	case nomem => return 14;
+	};
+	return 0;
+};

test/wcc/data/r926_sret_wide_multicall/case.ww

@@ -0,0 +1,25 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row wide_multicall.
+package main;
+type oops = !str;
+type nomem = !void;
+type wide = struct { xs: []u8, ys: []u8, n: i64 };
+fn mk(b: []u8, n: i64) (wide | oops | nomem) = {
+	return wide { xs = b, ys = b, n = n };
+};
+export fn main() i32 = {
+	let buf: [4]u8 = [1u8, 2u8, 3u8, 4u8];
+	let r1: (wide | oops | nomem) = mk(buf[0:4], 100);
+	let r2: (wide | oops | nomem) = mk(buf[0:4], 200);
+	match (r1) {
+	case let w: wide => { if (w.n != 100) { return 1; }; };
+	case let e: oops => return 13;
+	case nomem => return 14;
+	};
+	match (r2) {
+	case let w: wide => { if (w.n != 200) { return 2; }; };
+	case let e: oops => return 13;
+	case nomem => return 14;
+	};
+	return 0;
+};

test/wcc/data/r926_sret_wide_s4_repro/case.ww

@@ -0,0 +1,22 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row wide_s4_repro.
+package main;
+type s4 = struct { a: i64, b: i64, c: i64, d: i64 };
+fn taglit4() (s4 | bool) = {
+	return s4 { a = 1, b = 2, c = 3, d = 4 };
+};
+fn taglocal4() (s4 | bool) = {
+	let v: s4 = s4 { a = 1, b = 2, c = 3, d = 4 };
+	return v;
+};
+export fn main() i32 = {
+	match (taglit4()) {
+	case let r: s4 => { if (r.d != 4) { return 2; }; };
+	case let b: bool => return 3;
+	};
+	match (taglocal4()) {
+	case let r: s4 => { if (r.d != 4) { return 4; }; };
+	case let b: bool => return 5;
+	};
+	return 0;
+};

test/wcc/data/r926_sret_wide_str_error_variant/case.ww

@@ -0,0 +1,21 @@
+//ww:run-exit 0
+// Run leg of the retired 926_tagged_sret_run.c row wide_str_error_variant.
+package main;
+type oops = !str;
+type nomem = !void;
+type wide = struct { xs: []u8, ys: []u8, n: i64 };
+fn mk(b: []u8, n: i64) (wide | oops | nomem) = {
+	if (n < 0) { return "neg": oops; };
+	return wide { xs = b, ys = b, n = n };
+};
+export fn main() i32 = {
+	let buf: [4]u8 = [1u8, 2u8, 3u8, 4u8];
+	match (mk(buf[0:4], -1)) {
+	case let w: wide => return 1;
+	case let e: oops => {
+		if ((e: str).len != 3) { return 2; };
+	};
+	case nomem => return 3;
+	};
+	return 0;
+};

test/wcc/data/r929_memarg_boundary48_register/case.ww

@@ -0,0 +1,26 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row boundary48_register.
+package main;
+type t_lit = rune;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size };
+type t_u = (t_lit | t_rep);
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => { return 1; };
+	case let r: t_rep => {
+		if (r.m2 != 12) { return 92; };
+		return 2;
+	};
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let a: t_u = ('x': t_lit);
+	if (probe(a) != 1) { return 1; };
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10,
+		m1 = 11, m2 = 12 };
+	let b: t_u = r;
+	if (probe(b) != 2) { return 2; };
+	return 0;
+};

test/wcc/data/r929_memarg_global_uninit_memarg_src/case.ww

@@ -0,0 +1,28 @@
+//ww:run-exit 91
+// Run leg of the retired 929_tagged_memarg_run.c row global_uninit_memarg_src.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+let g: t_u;
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => {
+		if (l == 'x') { return 1; };
+		return 91;
+	};
+	case t_any => { return 2; };
+	case let r: t_rep => {
+		if (r.m3 != 1234) { return 92; };
+		if (r.m2 != 12) { return 93; };
+		if (r.id != 7) { return 94; };
+		return 3;
+	};
+	};
+	return 99;
+};
+export fn main() i32 = {
+	return probe(g);
+};

test/wcc/data/r929_memarg_idcast_peeled/case.ww

@@ -0,0 +1,29 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row memarg_idcast_peeled.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => {
+		if (l == 'x') { return 1; };
+		return 91;
+	};
+	case t_any => { return 2; };
+	case let r: t_rep => {
+		if (r.m3 != 1234) { return 92; };
+		if (r.m2 != 12) { return 93; };
+		if (r.id != 7) { return 94; };
+		return 3;
+	};
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let a: t_u = ('x': t_lit);
+	if (probe((a: t_u)) != 1) { return 1; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_call_in_loop/case.ww

@@ -0,0 +1,30 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_call_in_loop.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+fn grab(a: t_u) i64 = {
+	match (a) {
+	case let r: t_rep => { return r.m3: i64; };
+	case => { return -1; };
+	};
+	return -2;
+};
+export fn main() i32 = {
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10, m1 = 11, m2 = 12,
+	m3 = 1234 };
+	let a: t_u = r;
+	let canary: i64 = 4242;
+	let sum: i64 = 0;
+	let i: i64 = 0;
+	for (i < 200000) {
+		sum += grab(a) - 1234;
+		i += 1;
+	};
+	if (canary != 4242) { return 2; };
+	if (sum != 0) { return 1; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_elem_callidx_twomem/case.ww

@@ -0,0 +1,42 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_elem_callidx_twomem.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => {
+		if (l == 'x') { return 1; };
+		return 91;
+	};
+	case t_any => { return 2; };
+	case let r: t_rep => {
+		if (r.m3 != 1234) { return 92; };
+		if (r.m2 != 12) { return 93; };
+		if (r.id != 7) { return 94; };
+		return 3;
+	};
+	};
+	return 99;
+};
+fn pick() size = {
+	return 1;
+};
+fn two(a: t_u, b: t_u) i32 = {
+	return probe(a) * 10 + probe(b);
+};
+export fn main() i32 = {
+	let xs: []t_u = [];
+	let a: t_u = ('x': t_lit);
+	append(xs, a);
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10, m1 = 11, m2 = 12,
+	m3 = 1234 };
+	let b: t_u = r;
+	append(xs, b);
+	if (two(xs[0], xs[pick()]) != 13) { return 1; };
+	if (two(xs[pick()], xs[0]) != 31) { return 2; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_elem_deref_spine/case.ww

@@ -0,0 +1,34 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_elem_deref_spine.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => {
+		if (l == 'x') { return 1; };
+		return 91;
+	};
+	case t_any => { return 2; };
+	case let r: t_rep => {
+		if (r.m3 != 1234) { return 92; };
+		if (r.m2 != 12) { return 93; };
+		if (r.id != 7) { return 94; };
+		return 3;
+	};
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let xs: []t_u = [];
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10, m1 = 11, m2 = 12,
+	m3 = 1234 };
+	let b: t_u = r;
+	append(xs, b);
+	let p: *[]t_u = &xs;
+	if (probe((*p)[0]) != 3) { return 1; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_elem_global_slice/case.ww

@@ -0,0 +1,33 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_elem_global_slice.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+let gxs: []t_u;
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => {
+		if (l == 'x') { return 1; };
+		return 91;
+	};
+	case t_any => { return 2; };
+	case let r: t_rep => {
+		if (r.m3 != 1234) { return 92; };
+		if (r.m2 != 12) { return 93; };
+		if (r.id != 7) { return 94; };
+		return 3;
+	};
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10, m1 = 11, m2 = 12,
+	m3 = 1234 };
+	let b: t_u = r;
+	append(gxs, b);
+	if (probe(gxs[0]) != 3) { return 1; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_elem_mixed_regs/case.ww

@@ -0,0 +1,36 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_elem_mixed_regs.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+fn before(k: i64, s: str, a: t_u) i64 = {
+	if (k != 5) { return 91; };
+	if (s.len != 3) { return 92; };
+	match (a) {
+	case let r: t_rep => { return k + (r.m3: i64); };
+	case => { return 93; };
+	};
+	return 99;
+};
+fn after(a: t_u, k: i64, s: str) i64 = {
+	if (k != 6) { return 91; };
+	if (s.len != 3) { return 92; };
+	match (a) {
+	case let r: t_rep => { return k + (r.m3: i64); };
+	case => { return 93; };
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let xs: []t_u = [];
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10, m1 = 11, m2 = 12,
+	m3 = 1234 };
+	let b: t_u = r;
+	append(xs, b);
+	if (before(5, "abc", xs[0]) != 1239) { return 1; };
+	if (after(xs[0], 6, "abc") != 1240) { return 2; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_elem_nested_spine/case.ww

@@ -0,0 +1,40 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_elem_nested_spine.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+type re_t = struct { flag: i64, insts: []t_u };
+type thr = struct { pc: size, gen: i64 };
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => {
+		if (l == 'x') { return 1; };
+		return 91;
+	};
+	case t_any => { return 2; };
+	case let r: t_rep => {
+		if (r.m3 != 1234) { return 92; };
+		if (r.m2 != 12) { return 93; };
+		if (r.id != 7) { return 94; };
+		return 3;
+	};
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let xs: []t_u = [];
+	let a: t_u = ('x': t_lit);
+	append(xs, a);
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10, m1 = 11, m2 = 12,
+	m3 = 1234 };
+	let b: t_u = r;
+	append(xs, b);
+	let re: re_t = re_t { flag = 4, insts = xs };
+	let threads: []thr = [];
+	append(threads, thr { pc = 1, gen = 5 });
+	if (probe(re.insts[threads[0].pc]) != 3) { return 1; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_elem_source/case.ww

@@ -0,0 +1,38 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_elem_source.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => {
+		if (l == 'x') { return 1; };
+		return 91;
+	};
+	case t_any => { return 2; };
+	case let r: t_rep => {
+		if (r.m3 != 1234) { return 92; };
+		if (r.m2 != 12) { return 93; };
+		if (r.id != 7) { return 94; };
+		return 3;
+	};
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let xs: []t_u = [];
+	let a: t_u = ('x': t_lit);
+	append(xs, a);
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10, m1 = 11, m2 = 12,
+	m3 = 1234 };
+	let b: t_u = r;
+	append(xs, b);
+	if (probe(xs[0]) != 1) { return 1; };
+	if (probe(xs[1]) != 3) { return 2; };
+	let i: size = 1;
+	if (probe(xs[i]) != 3) { return 3; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_ident_allvariants/case.ww

@@ -0,0 +1,36 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_ident_allvariants.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => {
+		if (l == 'x') { return 1; };
+		return 91;
+	};
+	case t_any => { return 2; };
+	case let r: t_rep => {
+		if (r.m3 != 1234) { return 92; };
+		if (r.m2 != 12) { return 93; };
+		if (r.id != 7) { return 94; };
+		return 3;
+	};
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let a: t_u = ('x': t_lit);
+	if (probe(a) != 1) { return 1; };
+	let av: t_any;
+	let b: t_u = av;
+	if (probe(b) != 2) { return 2; };
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10, m1 = 11, m2 = 12,
+	m3 = 1234 };
+	let cc: t_u = r;
+	if (probe(cc) != 3) { return 3; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_inst_shape/case.ww

@@ -0,0 +1,28 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_inst_shape.
+package main;
+type inst_lit = rune;
+type inst_any = void;
+type inst_repeat = struct { id: size, origin: size,
+	min: (void | size), max: (void | size) };
+type inst = (inst_lit | inst_any | inst_repeat);
+fn is_consuming(a: inst) bool = {
+	return a is inst_lit || a is inst_any;
+};
+fn rep_id(a: inst) i64 = {
+	match (a) {
+	case let r: inst_repeat => { return r.origin: i64; };
+	case => { return -1; };
+	};
+	return -2;
+};
+export fn main() i32 = {
+	let a: inst = ('x': inst_lit);
+	if (!is_consuming(a)) { return 1; };
+	let r: inst_repeat = inst_repeat { id = 7, origin = 9,
+		min = (11: size), max = (1234: size) };
+	let b: inst = r;
+	if (is_consuming(b)) { return 2; };
+	if (rep_id(b) != 9) { return 3; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_mixed_orders/case.ww

@@ -0,0 +1,34 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_mixed_orders.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+fn before(k: i64, s: str, a: t_u) i64 = {
+	if (k != 5) { return 91; };
+	if (s.len != 3) { return 92; };
+	match (a) {
+	case let r: t_rep => { return k + (r.m3: i64); };
+	case => { return 93; };
+	};
+	return 99;
+};
+fn after(a: t_u, k: i64, s: str) i64 = {
+	if (k != 6) { return 91; };
+	if (s.len != 3) { return 92; };
+	match (a) {
+	case let r: t_rep => { return k + (r.m3: i64); };
+	case => { return 93; };
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10, m1 = 11, m2 = 12,
+	m3 = 1234 };
+	let a: t_u = r;
+	if (before(5, "abc", a) != 1239) { return 1; };
+	if (after(a, 6, "abc") != 1240) { return 2; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_srcshapes/case.ww

@@ -0,0 +1,40 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_srcshapes.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+type holder = struct { k: i64, u: t_u };
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => {
+		if (l == 'x') { return 1; };
+		return 91;
+	};
+	case t_any => { return 2; };
+	case let r: t_rep => {
+		if (r.m3 != 1234) { return 92; };
+		if (r.m2 != 12) { return 93; };
+		if (r.id != 7) { return 94; };
+		return 3;
+	};
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let arr: [2]t_u = [
+		('x': t_lit): t_u,
+		('x': t_lit): t_u,
+	];
+	if (probe(arr[1]) != 1) { return 1; };
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10, m1 = 11, m2 = 12,
+	m3 = 1234 };
+	let h: holder = holder { k = 9, u = r };
+	if (probe(h.u) != 3) { return 2; };
+	let x: t_u = ('x': t_lit);
+	let p: *t_u = &x;
+	if (probe(*p) != 1) { return 3; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_subset_remap/case.ww

@@ -0,0 +1,32 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_subset_remap.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+type t_sub = (t_lit | t_any);
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => {
+		if (l == 'x') { return 1; };
+		return 91;
+	};
+	case t_any => { return 2; };
+	case let r: t_rep => {
+		if (r.m3 != 1234) { return 92; };
+		if (r.m2 != 12) { return 93; };
+		if (r.id != 7) { return 94; };
+		return 3;
+	};
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let s: t_sub = ('x': t_lit);
+	if (probe(s) != 1) { return 1; };
+	let s2: t_sub = (void: t_any);
+	if (probe(s2) != 2) { return 2; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_twomem/case.ww

@@ -0,0 +1,33 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_twomem.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+type w_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size, m4: size };
+type w_u = (t_lit | w_rep);
+fn both(a: t_u, b: w_u) i64 = {
+	let x: i64 = 0;
+	match (a) {
+	case let r: t_rep => { x = r.m3: i64; };
+	case => { return 91; };
+	};
+	match (b) {
+	case let r: w_rep => { return x + (r.m4: i64); };
+	case => { return 92; };
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10, m1 = 11, m2 = 12,
+	m3 = 1234 };
+	let a: t_u = r;
+	let w: w_rep = w_rep { id = 1, origin = 2, m0 = 3,
+		m1 = 4, m2 = 5, m3 = 6, m4 = 2 };
+	let b: w_u = w;
+	if (both(a, b) != 1236) { return 1; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem56_widen_concrete/case.ww

@@ -0,0 +1,33 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem56_widen_concrete.
+package main;
+type t_lit = rune;
+type t_any = void;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size };
+type t_u = (t_lit | t_any | t_rep);
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => {
+		if (l == 'x') { return 1; };
+		return 91;
+	};
+	case t_any => { return 2; };
+	case let r: t_rep => {
+		if (r.m3 != 1234) { return 92; };
+		if (r.m2 != 12) { return 93; };
+		if (r.id != 7) { return 94; };
+		return 3;
+	};
+	};
+	return 99;
+};
+export fn main() i32 = {
+	if (probe('x': t_lit) != 1) { return 1; };
+	let av: t_any;
+	if (probe(av) != 2) { return 2; };
+	let r: t_rep = t_rep { id = 7, origin = 9, m0 = 10, m1 = 11, m2 = 12,
+	m3 = 1234 };
+	if (probe(r) != 3) { return 3; };
+	return 0;
+};

test/wcc/data/r929_memarg_mem64_ident_lateword/case.ww

@@ -0,0 +1,30 @@
+//ww:run-exit 0
+// Run leg of the retired 929_tagged_memarg_run.c row mem64_ident_lateword.
+package main;
+type t_lit = rune;
+type t_rep = struct { id: size, origin: size, m0: size,
+	m1: size, m2: size, m3: size, m4: size };
+type t_u = (t_lit | t_rep);
+fn probe(a: t_u) i32 = {
+	match (a) {
+	case let l: t_lit => {
+		if (l == 'y') { return 1; };
+		return 91;
+	};
+	case let r: t_rep => {
+		if (r.m4 != 7777) { return 92; };
+		if (r.m3 != 5) { return 93; };
+		return 2;
+	};
+	};
+	return 99;
+};
+export fn main() i32 = {
+	let a: t_u = ('y': t_lit);
+	if (probe(a) != 1) { return 1; };
+	let r: t_rep = t_rep { id = 1, origin = 2, m0 = 3,
+		m1 = 4, m2 = 5, m3 = 5, m4 = 7777 };
+	let b: t_u = r;
+	if (probe(b) != 2) { return 2; };
+	return 0;
+};