// Tuple arc layout SSoT (user-ratified): the tuple
// SLOT layout (str/slice = 24B header, everything else one 8B eightbyte;
// tagged = roundup8(size(elem))) is the single source of truth the checker
// size, the cgen cursor transports, and the t.N read walk all agree on.
// Migrated from test/wcc/941_tuple_slot_layout_run.c — the value rows become
// @test fns here (T1 `ww test` runs the runtime asserts; T2 test-lang-byteid
// keeps cs==ww); the reject rows become fold-3 //ww:error carriers under
// test/wcc/data/tslot_*/. Never-taken match arms / failure-checks that were
// `return K` become assert(false) / assert(!(COND)).
//
// Helper fns and types are suffixed with the row label to keep each migrated
// `package main` row's decls collision-free at this single file scope.

package tuple_slot_layout_test;

fn f_letcall_packed() (u32, u32) = {
	return (3, 4);
};

@test fn letcall_packed() void = {
	let t: (u32, u32) = f_letcall_packed();
	assert(!(t.0 != 3));
	assert(!(t.1 != 4));
};

fn f_letcall_float_packed() (u32, f64) = {
	let a: u32 = 9;
	let x: f64 = 2.5;
	return (a, x);
};

@test fn letcall_float_packed() void = {
	let t: (u32, f64) = f_letcall_float_packed();
	assert(!(t.0 != 9));
	assert(!(t.1 != 2.5));
};

fn f_letcall_signed_packed() (i32, i32) = {
	let a: i32 = -5;
	let b: i32 = -6;
	return (a, b);
};

@test fn letcall_signed_packed() void = {
	let t: (i32, i32) = f_letcall_signed_packed();
	assert(!(t.0 != -5));
	assert(!(t.1 != -6));
	assert(!(t.0 + t.1 != -11));
};

fn f_letcall_mixed_packed() (u32, str) = {
	let a: u32 = 7;
	let s: str = "hello";
	return (a, s);
};

@test fn letcall_mixed_packed() void = {
	let t: (u32, str) = f_letcall_mixed_packed();
	assert(!(t.0 != 7));
	assert(!(len(t.1) != 5));
};

fn f_letcall_16_neutral() (i64, i64) = {
	return (41, 17);
};

@test fn letcall_16_neutral() void = {
	let t: (i64, i64) = f_letcall_16_neutral();
	assert(!(t.0 != 41));
	assert(!(t.1 != 17));
};

fn f_letcall_32_neutral() (i64, str) = {
	let a: i64 = 12;
	let s: str = "wxyz";
	return (a, s);
};

@test fn letcall_32_neutral() void = {
	let t: (i64, str) = f_letcall_32_neutral();
	assert(!(t.0 != 12));
	assert(!(len(t.1) != 4));
};

fn f_mlet_packed_neutral() (u32, u32) = {
	return (3, 4);
};

@test fn mlet_packed_neutral() void = {
	let (a, b) = f_mlet_packed_neutral();
	assert(!(a != 3));
	assert(!(b != 4));
};

@test fn c0_sizefold_slot() void = {
	assert(!(size((u32, u32)) != 16));
	assert(!(size((size, size)) != 16));
	assert(!(size((u32, str)) != 32));
	assert(!(size((str, str)) != 48));
	assert(!(align((u32, u32)) != 4));
};

type holder_c0_sizefold_recursive = struct { t: (u32, u32), x: i64 };

@test fn c0_sizefold_recursive() void = {
	assert(!(size(holder_c0_sizefold_recursive) != 24));
	assert(!(size([4](u32, u32)) != 64));
};

@test fn t22_sizefold_tagged() void = {
	assert(!(size(((void | size), size)) != 24));
	assert(!(size((size, (void | size))) != 24));
	assert(!(size(((void | size), (void | size), size)) != 40));
	assert(!(align(((void | size), size)) != 8));
	assert(!(size((u64, void)) != 8));
};

fn mk_t22_roundtrip() ((void | size), size) = {
	let mn: (void | size) = 5: size;
	return (mn, 4);
};

fn mk2_t22_roundtrip() (size, (void | size)) = {
	let mx: (void | size) = 7: size;
	return (9, mx);
};

fn mkv_t22_roundtrip() ((void | size), size) = {
	let mn: (void | size) = void;
	return (mn, 3);
};

@test fn t22_roundtrip() void = {
	let t = mk_t22_roundtrip();
	assert(!(!(t.0 is size)));
	assert(!(t.0 as size != 5));
	assert(!(t.1 != 4));
	let u = mk2_t22_roundtrip();
	assert(!(u.0 != 9));
	assert(!(!(u.1 is size)));
	assert(!(u.1 as size != 7));
	let v = mkv_t22_roundtrip();
	assert(!(!(v.0 is void)));
	assert(!(v.1 != 3));
	let (a, b) = mk_t22_roundtrip();
	assert(!(!(a is size)));
	assert(!(a as size != 5));
	assert(!(b != 4));
	let mn: (void | size) = 6: size;
	let w: ((void | size), size) = (mn, 2);
	assert(!(!(w.0 is size)));
	assert(!(w.0 as size != 6));
	assert(!(w.1 != 2));
};

fn mk_t22_float_mix() (f64, (void | size), i64) = {
	let mn: (void | size) = 6: size;
	return (2.5, mn, 9);
};

@test fn t22_float_mix() void = {
	let t = mk_t22_float_mix();
	assert(!(t.0 != 2.5));
	assert(!(!(t.1 is size)));
	assert(!(t.1 as size != 6));
	assert(!(t.2 != 9));
	let (x, y, z) = mk_t22_float_mix();
	assert(!(x != 2.5));
	assert(!(!(y is size)));
	assert(!(y as size != 6));
	assert(!(z != 9));
};

fn mk_t22_two_tagged() ((void | u32), (void | i64)) = {
	let a: (void | u32) = 9: u32;
	let b: (void | i64) = -5: i64;
	return (a, b);
};

fn mkv_t22_two_tagged() ((void | u32), (void | i64)) = {
	let a: (void | u32) = void;
	let b: (void | i64) = -41: i64;
	return (a, b);
};

@test fn t22_two_tagged() void = {
	let t = mk_t22_two_tagged();
	assert(!(!(t.0 is u32)));
	assert(!(t.0 as u32 != 9));
	assert(!(!(t.1 is i64)));
	assert(!(t.1 as i64 != -5));
	let v = mkv_t22_two_tagged();
	assert(!(!(v.0 is void)));
	assert(!(v.1 as i64 != -41));
	let (a, b) = mk_t22_two_tagged();
	assert(!(a as u32 != 9));
	assert(!(b as i64 != -5));
};

fn mk_t22_float_mix_rev() ((void | size), f64) = {
	let mn: (void | size) = 6: size;
	return (mn, 0.25);
};

@test fn t22_float_mix_rev() void = {
	let t = mk_t22_float_mix_rev();
	assert(!(!(t.0 is size)));
	assert(!(t.0 as size != 6));
	assert(!(t.1 != 0.25));
	let (y, z) = mk_t22_float_mix_rev();
	assert(!(y as size != 6));
	assert(!(z != 0.25));
};

fn takes_t22_elem_arg(v: (void | size)) size = {
	if (v is size) { return v as size; };
	return 0;
};

@test fn t22_elem_arg() void = {
	let mn: (void | size) = 5: size;
	let t: ((void | size), size) = (mn, 4);
	assert(!(takes_t22_elem_arg(t.0) != 5));
	assert(!(takes_t22_elem_arg(t.0) + t.1 != 9));
};

fn pr_b22_parse_repetition() ((void | size), (void | size), size) = {
	let mn: (void | size) = void;
	let mx: (void | size) = 5: size;
	mn = 3: size;
	return (mn, mx, 9);
};

@test fn b22_parse_repetition() void = {
	let t = pr_b22_parse_repetition();
	assert(!(!(t.0 is size)));
	assert(!(t.0 as size != 3));
	assert(!(!(t.1 is size)));
	assert(!(t.1 as size != 5));
	assert(!(t.2 != 9));
	let (a, b, n) = pr_b22_parse_repetition();
	assert(!(a as size != 3));
	assert(!(b as size != 5));
	assert(!(n != 9));
	let a2: (void | size) = void;
	let b2: (void | size) = void;
	let n2: size = 0;
	a2, b2, n2 = pr_b22_parse_repetition();
	assert(!(a2 as size != 3));
	assert(!(b2 as size != 5));
	assert(!(n2 != 9));
};

fn ph_b22_head_mid_tail() ((void | size), size, size, size, size) = {
	let a: (void | size) = 11: size;
	return (a, 1, 2, 3, 4);
};

fn pm_b22_head_mid_tail() (size, size, (void | size), size, size) = {
	let a: (void | size) = 12: size;
	return (1, 2, a, 3, 4);
};

fn pt_b22_head_mid_tail() (size, size, size, size, (void | size)) = {
	let a: (void | size) = 13: size;
	return (1, 2, 3, 4, a);
};

fn pv_b22_head_mid_tail() ((void | size), (void | size), size) = {
	let a: (void | size) = void;
	let b: (void | size) = void;
	return (a, b, 9);
};

@test fn b22_head_mid_tail() void = {
	let h = ph_b22_head_mid_tail();
	assert(!(h.0 as size != 11));
	assert(!(h.4 != 4));
	let m = pm_b22_head_mid_tail();
	assert(!(m.0 != 1));
	assert(!(m.2 as size != 12));
	assert(!(m.4 != 4));
	let t = pt_b22_head_mid_tail();
	assert(!(t.3 != 4));
	assert(!(t.4 as size != 13));
	let v = pv_b22_head_mid_tail();
	assert(!(!(v.0 is void)));
	assert(!(!(v.1 is void)));
	assert(!(v.2 != 9));
	let (x, y, z) = v;
	assert(!(!(x is void)));
	assert(!(!(y is void)));
	assert(!(z != 9));
};

fn pr_b22_str_tagged_mix() (str, (void | size), size, size) = {
	let mid: (void | size) = 4: size;
	return ("hello", mid, 6, 7);
};

@test fn b22_str_tagged_mix() void = {
	let t = pr_b22_str_tagged_mix();
	assert(!(t.0.len != 5));
	assert(!(t.1 as size != 4));
	assert(!(t.2 != 6));
	assert(!(t.3 != 7));
};

fn pr_b22_sse_mix() ((void | size), f64, f64, f64) = {
	let a: (void | size) = 6: size;
	return (a, 1.5, 2.5, 3.5);
};

@test fn b22_sse_mix() void = {
	let t = pr_b22_sse_mix();
	assert(!(t.0 as size != 6));
	assert(!(t.1 != 1.5));
	assert(!(t.2 != 2.5));
	assert(!(t.3 != 3.5));
	let (a, x, y, z) = pr_b22_sse_mix();
	assert(!(a as size != 6));
	assert(!(x != 1.5));
	assert(!(y != 2.5));
	assert(!(z != 3.5));
};

fn pr_b22_underscore_skip() ((void | size), (void | size), size) = {
	let mn: (void | size) = 3: size;
	let mx: (void | size) = 5: size;
	return (mn, mx, 9);
};

@test fn b22_underscore_skip() void = {
	let a: (void | size) = void;
	let n: size = 0;
	a, _, n = pr_b22_underscore_skip();
	assert(!(a as size != 3));
	assert(!(n != 9));
	let (q, _, r) = pr_b22_underscore_skip();
	assert(!(q as size != 3));
	assert(!(r != 9));
};

type four_c37_big_box_t0_read = struct { a: u64, b: u64, c: u64, d: u64, };

fn g_c37_big_box_t0_read() (void | four_c37_big_box_t0_read) = {
	let v: four_c37_big_box_t0_read = four_c37_big_box_t0_read{a=1u64, b=2u64, c=3u64, d=4u64};
	return v;
};

fn pr_c37_big_box_t0_read() ((void | four_c37_big_box_t0_read), size) = {
	let e: (void | four_c37_big_box_t0_read) = g_c37_big_box_t0_read();
	return (e, 7);
};

@test fn c37_big_box_t0_read() void = {
	let t = pr_c37_big_box_t0_read();
	assert(!(t.1 != 7));
	assert(!(!(t.0 is four_c37_big_box_t0_read)));
	match (t.0) {
	case let f: four_c37_big_box_t0_read => {
		assert(!(f.a != 1));
		assert(!(f.b != 2));
		assert(!(f.c != 3));
		assert(!(f.d != 4));
	};
	case void => { assert(false); };
	};
};

type inst_lit_c37_idx_match_56 = rune;
type inst_repeat_c37_idx_match_56 = struct {
	id: size,
	origin: size,
	min: (void | size),
	max: (void | size),
};
type inst_c37_idx_match_56 = (inst_lit_c37_idx_match_56 | inst_repeat_c37_idx_match_56);

@test fn c37_idx_match_56() void = {
	let insts: []inst_c37_idx_match_56 = [];
	let r = inst_repeat_c37_idx_match_56{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
	append(insts, r);
	append(insts, ('A': inst_lit_c37_idx_match_56));
	let pc: size = 0;
	match (insts[pc]) {
	case let ir: inst_repeat_c37_idx_match_56 => {
		assert(!(ir.id != 7));
		assert(!(ir.origin != 3));
		assert(!(!(ir.min is size)));
		assert(!(ir.min as size != 11));
		assert(!(!(ir.max is size)));
		assert(!(ir.max as size != 22));
	};
	case let l: inst_lit_c37_idx_match_56 => { assert(false); };
	};
	match (insts[1]) {
	case let l: inst_lit_c37_idx_match_56 => {
		assert(!(l != 'A'));
	};
	case let ir: inst_repeat_c37_idx_match_56 => { assert(false); };
	};
};

type lit2_c37_idx_match_str_nested = rune;
type rep2_c37_idx_match_str_nested = struct {
	name: str,
	min: (void | size),
	max: (void | size),
};
type in2_c37_idx_match_str_nested = (lit2_c37_idx_match_str_nested | rep2_c37_idx_match_str_nested);

@test fn c37_idx_match_str_nested() void = {
	let xs: []in2_c37_idx_match_str_nested = [];
	let r = rep2_c37_idx_match_str_nested{name="deadbeef", min=(2: size), max=(5: size)};
	append(xs, r);
	match (xs[0]) {
	case let v: rep2_c37_idx_match_str_nested => {
		assert(!(v.name.len != 8));
		assert(!(v.name[0] != 'd'));
		assert(!(v.name[7] != 'f'));
		assert(!(!(v.min is size)));
		assert(!(v.min as size != 2));
		assert(!(v.max as size != 5));
	};
	case let l: lit2_c37_idx_match_str_nested => { assert(false); };
	};
};

type inst_lit_c37_idx_let_is_assign = rune;
type inst_repeat_c37_idx_let_is_assign = struct {
	id: size,
	origin: size,
	min: (void | size),
	max: (void | size),
};
type inst_c37_idx_let_is_assign = (inst_lit_c37_idx_let_is_assign | inst_repeat_c37_idx_let_is_assign);

@test fn c37_idx_let_is_assign() void = {
	let insts: []inst_c37_idx_let_is_assign = [];
	let r = inst_repeat_c37_idx_let_is_assign{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
	append(insts, r);
	append(insts, ('A': inst_lit_c37_idx_let_is_assign));
	assert(!(!(insts[0] is inst_repeat_c37_idx_let_is_assign)));
	assert(!(insts[0] is inst_lit_c37_idx_let_is_assign));
	let w = insts[0];
	match (w) {
	case let ir: inst_repeat_c37_idx_let_is_assign => {
		assert(!(ir.max as size != 22));
	};
	case let l: inst_lit_c37_idx_let_is_assign => { assert(false); };
	};
	w = insts[1];
	assert(!(!(w is inst_lit_c37_idx_let_is_assign)));
	w = insts[0];
	match (w) {
	case let ir: inst_repeat_c37_idx_let_is_assign => {
		assert(!(ir.min as size != 11));
	};
	case let l: inst_lit_c37_idx_let_is_assign => { assert(false); };
	};
};

type inst_lit_c37_idx_return = rune;
type inst_repeat_c37_idx_return = struct {
	id: size,
	origin: size,
	min: (void | size),
	max: (void | size),
};
type inst_c37_idx_return = (inst_lit_c37_idx_return | inst_repeat_c37_idx_return);

fn pick_c37_idx_return(insts: []inst_c37_idx_return, pc: size) inst_c37_idx_return = {
	return insts[pc];
};

@test fn c37_idx_return() void = {
	let insts: []inst_c37_idx_return = [];
	let r = inst_repeat_c37_idx_return{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
	append(insts, r);
	let w = pick_c37_idx_return(insts, 0);
	match (w) {
	case let ir: inst_repeat_c37_idx_return => {
		assert(!(ir.id != 7));
		assert(!(ir.min as size != 11));
	};
	case let l: inst_lit_c37_idx_return => { assert(false); };
	};
};

type inst_lit_c37_widen_and_memarg = rune;
type inst_repeat_c37_widen_and_memarg = struct {
	id: size,
	origin: size,
	min: (void | size),
	max: (void | size),
};
type inst_c37_widen_and_memarg = (inst_lit_c37_widen_and_memarg | inst_repeat_c37_widen_and_memarg);
type wide_c37_widen_and_memarg = (inst_lit_c37_widen_and_memarg | inst_repeat_c37_widen_and_memarg | str);

fn idof_c37_widen_and_memarg(i: inst_c37_widen_and_memarg) size = {
	match (i) {
	case let ir: inst_repeat_c37_widen_and_memarg => { return ir.id; };
	case let l: inst_lit_c37_widen_and_memarg => { return 999; };
	};
	return 998;
};

@test fn c37_widen_and_memarg() void = {
	let insts: []inst_c37_widen_and_memarg = [];
	let r = inst_repeat_c37_widen_and_memarg{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
	append(insts, r);
	let w: wide_c37_widen_and_memarg = insts[0];
	match (w) {
	case let ir: inst_repeat_c37_widen_and_memarg => {
		assert(!(ir.max as size != 22));
	};
	case let l: inst_lit_c37_widen_and_memarg => { assert(false); };
	case let s2: str => { assert(false); };
	};
	assert(!(idof_c37_widen_and_memarg(insts[0]) != 7));
};

type inst_lit_c37_widen_remap = rune;
type inst_repeat_c37_widen_remap = struct {
	id: size,
	origin: size,
	min: (void | size),
	max: (void | size),
};
type rev_c37_widen_remap = (inst_repeat_c37_widen_remap | inst_lit_c37_widen_remap);
type wide_c37_widen_remap = (inst_lit_c37_widen_remap | inst_repeat_c37_widen_remap | str);

@test fn c37_widen_remap() void = {
	let xs: []rev_c37_widen_remap = [];
	let r = inst_repeat_c37_widen_remap{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
	append(xs, r);
	let w: wide_c37_widen_remap = xs[0];
	match (w) {
	case let ir: inst_repeat_c37_widen_remap => {
		assert(!(ir.id != 7));
		assert(!(!(ir.max is size)));
		assert(!(ir.max as size != 22));
	};
	case let l: inst_lit_c37_widen_remap => { assert(false); };
	case let s2: str => { assert(false); };
	};
};

type st_c37_x1_compose = struct { a: size, m: (void | size), };

fn pr_c37_x1_compose() ((void | st_c37_x1_compose), size, size) = {
	let e: (void | st_c37_x1_compose) = st_c37_x1_compose{a=4: size, m=(2: size)};
	return (e, 5, 6);
};

@test fn c37_x1_compose() void = {
	let t = pr_c37_x1_compose();
	assert(!(!(t.0 is st_c37_x1_compose)));
	match (t.0) {
	case let v: st_c37_x1_compose => {
		assert(!(v.a != 4));
		assert(!(!(v.m is size)));
		assert(!(v.m as size != 2));
	};
	case void => { assert(false); };
	};
	assert(!(t.1 != 5));
	assert(!(t.2 != 6));
};

type box_c37_idx_at_cap = (void | str);

@test fn c37_idx_at_cap() void = {
	let bs: []box_c37_idx_at_cap = [];
	let s: str = "abcdefgh";
	append(bs, s);
	match (bs[0]) {
	case let v: str => {
		assert(!(v.len != 8));
	};
	case void => { assert(false); };
	};
};

type inst_lit_c37_ptr_field_match = rune;
type inst_repeat_c37_ptr_field_match = struct {
	id: size,
	origin: size,
	min: (void | size),
	max: (void | size),
};
type inst_c37_ptr_field_match = (inst_lit_c37_ptr_field_match | inst_repeat_c37_ptr_field_match);
type holder_c37_ptr_field_match = struct { pre: size, f: inst_c37_ptr_field_match, };

@test fn c37_ptr_field_match() void = {
	let g = holder_c37_ptr_field_match{pre=9: size, f=inst_repeat_c37_ptr_field_match{id=7: size, origin=3: size, min=(11: size), max=(55: size)}};
	let p = &g;
	assert(!(!(p.f is inst_repeat_c37_ptr_field_match)));
	match (p.f) {
	case let ir: inst_repeat_c37_ptr_field_match => {
		assert(!(ir.id != 7));
		assert(!(ir.max as size != 55));
	};
	case let l: inst_lit_c37_ptr_field_match => { assert(false); };
	};
};

type inst_lit_c37_deref_idx_match = rune;
type inst_repeat_c37_deref_idx_match = struct {
	id: size,
	origin: size,
	min: (void | size),
	max: (void | size),
};
type inst_c37_deref_idx_match = (inst_lit_c37_deref_idx_match | inst_repeat_c37_deref_idx_match);

@test fn c37_deref_idx_match() void = {
	let insts: []inst_c37_deref_idx_match = [];
	let r = inst_repeat_c37_deref_idx_match{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
	append(insts, r);
	let p = &insts;
	match ((*p)[0]) {
	case let ir: inst_repeat_c37_deref_idx_match => {
		assert(!(ir.id != 7));
		assert(!(ir.max as size != 22));
	};
	case let l: inst_lit_c37_deref_idx_match => { assert(false); };
	};
};

type inst_lit_fc_deref_56_slice_let = rune;
type inst_repeat_fc_deref_56_slice_let = struct {
	id: size,
	origin: size,
	min: (void | size),
	max: (void | size),
};
type inst_fc_deref_56_slice_let = (inst_lit_fc_deref_56_slice_let | inst_repeat_fc_deref_56_slice_let);

@test fn fc_deref_56_slice_let() void = {
	let insts: []inst_fc_deref_56_slice_let = [];
	let r = inst_repeat_fc_deref_56_slice_let{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
	append(insts, r);
	let p = &insts[0];
	let w = *p;
	assert(!(!(w is inst_repeat_fc_deref_56_slice_let)));
	match (w) {
	case let ir: inst_repeat_fc_deref_56_slice_let => {
		assert(!(ir.id != 7 || ir.origin != 3));
		assert(!((ir.min as size) != 11));
		assert(!((ir.max as size) != 22));
	};
	case let l: inst_lit_fc_deref_56_slice_let => { assert(false); };
	};
};

type inst_lit_fc_deref_56_slice_match = rune;
type inst_repeat_fc_deref_56_slice_match = struct {
	id: size,
	origin: size,
	min: (void | size),
	max: (void | size),
};
type inst_fc_deref_56_slice_match = (inst_lit_fc_deref_56_slice_match | inst_repeat_fc_deref_56_slice_match);

@test fn fc_deref_56_slice_match() void = {
	let insts: []inst_fc_deref_56_slice_match = [];
	let r = inst_repeat_fc_deref_56_slice_match{id=7: size, origin=3: size, min=(11: size), max=(22: size)};
	append(insts, r);
	let p = &insts[0];
	match (*p) {
	case let ir: inst_repeat_fc_deref_56_slice_match => {
		assert(!(ir.id != 7));
		assert(!(!(ir.min is size)));
		assert(!((ir.max as size) != 22));
	};
	case let l: inst_lit_fc_deref_56_slice_match => { assert(false); };
	};
};

type four_b22_big_box_mlet = struct { a: u64, b: u64, c: u64, d: u64, };

fn g_b22_big_box_mlet() (void | four_b22_big_box_mlet) = {
	let v: four_b22_big_box_mlet = four_b22_big_box_mlet{a=1u64, b=2u64, c=3u64, d=4u64};
	return v;
};

fn pr_b22_big_box_mlet() ((void | four_b22_big_box_mlet), size) = {
	let e: (void | four_b22_big_box_mlet) = g_b22_big_box_mlet();
	return (e, 7);
};

@test fn b22_big_box_mlet() void = {
	let e2 = g_b22_big_box_mlet();
	assert(!(!(e2 is four_b22_big_box_mlet)));
	let (e, n) = pr_b22_big_box_mlet();
	assert(!(n != 7));
	assert(!(!(e is four_b22_big_box_mlet)));
};

fn mk_b22_void_elem_k4() (void, size, size, size, size, size) = {
	return (void, 1, 2, 3, 4, 5);
};

@test fn b22_void_elem_k4() void = {
	let (v, a, b, c, d, e) = mk_b22_void_elem_k4();
	assert(!(a != 1));
	assert(!(b != 2));
	assert(!(c != 3));
	assert(!(d != 4));
	assert(!(e != 5));
};

fn mk_b22_k5_box_at_cap() ((void | str), size, size) = {
	let m: (void | str) = "boundary";
	return (m, 5, 6);
};

@test fn b22_k5_box_at_cap() void = {
	let t = mk_b22_k5_box_at_cap();
	assert(!(!(t.0 is str)));
	match (t.0) {
	case let s: str => {
		assert(!(s.len != 8));
	};
	case void => { assert(false); };
	};
	assert(!(t.1 != 5));
	assert(!(t.2 != 6));
};

fn pr_b22_both_tagged_2elem() ((void | str), (void | size)) = {
	let a: (void | str) = "boundary";
	let b: (void | size) = 7: size;
	return (a, b);
};

@test fn b22_both_tagged_2elem() void = {
	let t = pr_b22_both_tagged_2elem();
	assert(!(!(t.0 is str)));
	match (t.0) {
	case let s: str => { assert(!(s.len != 8)); };
	case void => { assert(false); };
	};
	assert(!(!(t.1 is size)));
	assert(!(t.1 as size != 7));
	let (x, y) = pr_b22_both_tagged_2elem();
	assert(!(!(x is str)));
	assert(!(y as size != 7));
};

fn g_b22_chained_sret() ((void | size), (void | size), size) = {
	let mn: (void | size) = 3: size;
	let mx: (void | size) = 5: size;
	return (mn, mx, 9);
};

fn h_b22_chained_sret() ((void | size), (void | size), size) = {
	let (a, b, n) = g_b22_chained_sret();
	return (a, b, n + 1);
};

@test fn b22_chained_sret() void = {
	let t = h_b22_chained_sret();
	assert(!(t.0 as size != 3));
	assert(!(t.1 as size != 5));
	assert(!(t.2 != 10));
};

fn f_sret_narrow_mix_let() (str, u32, str) = {
	let a: str = "abc";
	let b: u32 = 7;
	let c: str = "wxyz";
	return (a, b, c);
};

@test fn sret_narrow_mix_let() void = {
	let t = f_sret_narrow_mix_let();
	assert(!(len(t.0) != 3));
	assert(!(t.1 != 7));
	assert(!(len(t.2) != 4));
};

fn f_sret_narrow_mix_mlet() (str, u32, str) = {
	let a: str = "abc";
	let b: u32 = 7;
	let c: str = "wxyz";
	return (a, b, c);
};

@test fn sret_narrow_mix_mlet() void = {
	let (a, b, c) = f_sret_narrow_mix_mlet();
	assert(!(len(a) != 3));
	assert(!(b != 7));
	assert(!(len(c) != 4));
};

fn f_sret_narrow_mix_massign() (str, u32, str) = {
	let a: str = "abc";
	let b: u32 = 7;
	let c: str = "wxyz";
	return (a, b, c);
};

@test fn sret_narrow_mix_massign() void = {
	let a: str = "";
	let b: u32 = 0;
	let c: str = "";
	a, b, c = f_sret_narrow_mix_massign();
	assert(!(len(a) != 3));
	assert(!(b != 7));
	assert(!(len(c) != 4));
};

fn second_t1_lit_packed() u32 = {
	let t: (u32, u32) = (3, 4);
	if (t.0 != 3) { return 99; };
	return t.1;
};

@test fn t1_lit_packed() void = {
	assert(!(second_t1_lit_packed() != 4));
};

@test fn t1_lit_16() void = {
	let t: (i64, i64) = (3, 4);
	assert(!(t.0 != 3));
	assert(!(t.1 != 4));
};

@test fn t1_lit_mixed() void = {
	let t: (i64, str) = (12, "wxyz");
	assert(!(t.0 != 12));
	assert(!(len(t.1) != 4));
};

fn second_t1_lit_3scalar() i64 = {
	let t: (i64, i64, i64) = (3, 4, 5);
	if (t.0 != 3) { return -1; };
	if (t.1 != 4) { return -2; };
	return t.2;
};

@test fn t1_lit_3scalar() void = {
	assert(!(second_t1_lit_3scalar() != 5));
};

fn f_t1_call_3scalar() (i64, i64, i64) = {
	return (7, 8, 9);
};

@test fn t1_call_3scalar() void = {
	let t: (i64, i64, i64) = f_t1_call_3scalar();
	assert(!(t.0 != 7));
	assert(!(t.1 != 8));
	assert(!(t.2 != 9));
};

fn f_t1_call_noannot_neutral() (i64, i64) = {
	return (3, 4);
};

@test fn t1_call_noannot_neutral() void = {
	let t = f_t1_call_noannot_neutral();
	assert(!(t.0 != 3));
	assert(!(t.1 != 4));
};

fn pick_t2_param_packed(t: (u32, u32), k: i32) u32 = {
	if (k == 0) { return t.0; };
	return t.1;
};

@test fn t2_param_packed() void = {
	let t: (u32, u32) = (41, 17);
	assert(!(pick_t2_param_packed(t, 0) != 41));
	assert(!(pick_t2_param_packed(t, 1) != 17));
};

fn pick_t2_param_16(t: (i64, i64), k: i32) i64 = {
	if (k == 0) { return t.0; };
	return t.1;
};

@test fn t2_param_16() void = {
	let t: (i64, i64) = (41, 17);
	assert(!(pick_t2_param_16(t, 0) != 41));
	assert(!(pick_t2_param_16(t, 1) != 17));
};

fn g_t2_mixed_order(a: i64, t: (u32, u32), b: i64) i64 = {
	return a*1000 + (t.0: i64)*100 + (t.1: i64)*10 + b;
};

fn h_t2_mixed_order(t: (i64, i64), s: str, k: i64) i64 = {
	return t.0 + t.1 + (len(s): i64) + k;
};

@test fn t2_mixed_order() void = {
	let t: (u32, u32) = (3, 4);
	assert(!(g_t2_mixed_order(1, t, 2) != 1342));
	let u: (i64, i64) = (10, 20);
	assert(!(h_t2_mixed_order(u, "abc", 7) != 40));
};

fn pick_t2_lit_arg(t: (i64, i64), k: i32) i64 = {
	if (k == 0) { return t.0; };
	return t.1;
};

@test fn t2_lit_arg() void = {
	assert(!(pick_t2_lit_arg((41, 17), 0) != 41));
	assert(!(pick_t2_lit_arg((41, 17), 1) != 17));
};

fn fsum_t2_float_param(t: (f64, i64)) f64 = {
	return t.0 + (t.1: f64);
};

@test fn t2_float_param() void = {
	let t: (f64, i64) = (2.5, 4);
	assert(!(fsum_t2_float_param(t) != 6.5));
};

fn mk_t2_unwrap_arg() ((i64, i64) | nomem) = {
	let a: i64 = 5;
	let b: i64 = 6;
	return (a, b);
};

fn sum_t2_unwrap_arg(t: (i64, i64)) i64 = {
	return t.0 + t.1;
};

@test fn t2_unwrap_arg() void = {
	assert(!(sum_t2_unwrap_arg(mk_t2_unwrap_arg()!) != 11));
};

fn f_t2_gp_pressure(a: i64, b: i64, c: i64, d: i64, t: (i64, i64), e: i64) i64 = {
	if (e != 60) { return -1; };
	if (a != 1 || b != 2 || c != 3 || d != 4) { return -2; };
	return t.0 * 100 + t.1;
};

@test fn t2_gp_pressure() void = {
	let t: (i64, i64) = (7, 9);
	assert(!(f_t2_gp_pressure(1, 2, 3, 4, t, 60) != 709));
};

fn g_t2_variadic_after_tuple(t: (i64, i64), xs: i64...) i64 = {
	let s: i64 = t.0 + t.1;
	for (let x .. xs) { s += x; };
	return s;
};

@test fn t2_variadic_after_tuple() void = {
	let t: (i64, i64) = (3, 4);
	assert(!(g_t2_variadic_after_tuple(t, 1, 2) != 10));
};

fn first_t2_variadic_of_tuples(ts: (i64, i64)...) i64 = {
	if (len(ts) == 0) { return -1; };
	return ts[0].0;
};

@test fn t2_variadic_of_tuples() void = {
	let t: (i64, i64) = (3, 4);
	assert(!(first_t2_variadic_of_tuples(t) != 3));
};

let g_t3_global_elem: (str, i64) = ("hello", 9);
let h_t3_global_elem: (u32, u32) = (5, 6);

@test fn t3_global_elem() void = {
	assert(!(len(g_t3_global_elem.0) != 5));
	assert(!(g_t3_global_elem.1 != 9));
	assert(!(h_t3_global_elem.0 != 5));
	assert(!(h_t3_global_elem.1 != 6));
};

fn take_fc_arg_deref_16(e: (void | size)) size = {
	if (!(e is size)) { return 99; };
	return e as size;
};

@test fn fc_arg_deref_16() void = {
	let v: (void | size) = 7: size;
	let p: *(void | size) = &v;
	assert(!(take_fc_arg_deref_16(*p) != 7));
};

type un16_fc_deref_let_match_16 = (void | size);

@test fn fc_deref_let_match_16() void = {
	let v: un16_fc_deref_let_match_16 = 5: size;
	let p: *un16_fc_deref_let_match_16 = &v;
	let w = *p;
	assert(!(!(w is size)));
	match (*p) {
	case let s: size => { assert(!(s != 5)); };
	case void => { assert(false); };
	};
};

type un32_fc_deref_let_match_32str = (void | str);

@test fn fc_deref_let_match_32str() void = {
	let v: un32_fc_deref_let_match_32str = "atcap";
	let p: *un32_fc_deref_let_match_32str = &v;
	let w = *p;
	assert(!(!(w is str)));
	match (*p) {
	case let s: str => { assert(!(s.len != 5)); };
	case void => { assert(false); };
	};
};

type un16_fc_deref_asg_16 = (void | size);

@test fn fc_deref_asg_16() void = {
	let v: un16_fc_deref_asg_16 = 5: size;
	let p: *un16_fc_deref_asg_16 = &v;
	let w: un16_fc_deref_asg_16 = void;
	w = *p;
	assert(!(!(w is size)));
	assert(!((w as size) != 5));
};

type un16_fc_deref_ret_16 = (void | size);

fn get_fc_deref_ret_16(p: *un16_fc_deref_ret_16) un16_fc_deref_ret_16 = {
	return *p;
};

@test fn fc_deref_ret_16() void = {
	let v: un16_fc_deref_ret_16 = 5: size;
	let w = get_fc_deref_ret_16(&v);
	assert(!(!(w is size)));
	assert(!((w as size) != 5));
};

type un16_fc_deref_is_as_16 = (void | size);

@test fn fc_deref_is_as_16() void = {
	let v: un16_fc_deref_is_as_16 = 5: size;
	let p: *un16_fc_deref_is_as_16 = &v;
	assert(!(!((*p) is size)));
	assert(!(((*p) as size) != 5));
};

type un32_fc_deref_as_32str = (void | str);

@test fn fc_deref_as_32str() void = {
	let v: un32_fc_deref_as_32str = "atcap";
	let p: *un32_fc_deref_as_32str = &v;
	let s = (*p) as str;
	assert(!(s.len != 5));
};

type un32_fc_deref_arg_32str = (void | str);

fn take_fc_deref_arg_32str(e: un32_fc_deref_arg_32str) i32 = {
	if (!(e is str)) { return 99; };
	let s = e as str;
	if (s.len != 5) { return 98; };
	return 0;
};

@test fn fc_deref_arg_32str() void = {
	let v: un32_fc_deref_arg_32str = "atcap";
	let p: *un32_fc_deref_arg_32str = &v;
	assert(!(take_fc_deref_arg_32str(*p) != 0));
};

type un16_fc_deref_widen_16to24 = (void | size);
type un3_fc_deref_widen_16to24 = (void | size | str);

@test fn fc_deref_widen_16to24() void = {
	let v: un16_fc_deref_widen_16to24 = 5: size;
	let p: *un16_fc_deref_widen_16to24 = &v;
	let w: un3_fc_deref_widen_16to24 = *p;
	assert(!(!(w is size)));
	assert(!((w as size) != 5));
};

type s2_fc_deref_struct24_neighbor = struct { a: size, b: size };
type un24_fc_deref_struct24_neighbor = (void | s2_fc_deref_struct24_neighbor);

@test fn fc_deref_struct24_neighbor() void = {
	let lo: size = 111;
	let v: un24_fc_deref_struct24_neighbor = s2_fc_deref_struct24_neighbor { a = 5, b = 6 };
	let hi: size = 222;
	let p: *un24_fc_deref_struct24_neighbor = &v;
	let w = *p;
	assert(!(!(w is s2_fc_deref_struct24_neighbor)));
	match (w) {
	case let s: s2_fc_deref_struct24_neighbor => { assert(!(s.a != 5 || s.b != 6)); };
	case void => { assert(false); };
	};
	assert(!(lo != 111));
	assert(!(hi != 222));
};

type big_fc_deref_56_memread = struct { a: u64, b: u64, c: u64, d: u64, e: u64, f: u64 };
type un56_fc_deref_56_memread = (void | big_fc_deref_56_memread);

@test fn fc_deref_56_memread() void = {
	let v: un56_fc_deref_56_memread = big_fc_deref_56_memread { a = 1u64, b = 2u64, c = 3u64, d = 4u64, e = 5u64, f = 6u64 };
	let p: *un56_fc_deref_56_memread = &v;
	let w = *p;
	assert(!(!(w is big_fc_deref_56_memread)));
	match (*p) {
	case let s: big_fc_deref_56_memread => { assert(!(s.a != 1u64 || s.f != 6u64)); };
	case void => { assert(false); };
	};
};

type un16_fc_cast_ident_arg = (void | size);

fn take_fc_cast_ident_arg(e: un16_fc_cast_ident_arg) size = {
	if (!(e is size)) { return 99; };
	return e as size;
};

@test fn fc_cast_ident_arg() void = {
	let v: un16_fc_cast_ident_arg = 7: size;
	assert(!(take_fc_cast_ident_arg((v: un16_fc_cast_ident_arg)) != 7));
};

type un16_fc_cast_widen_let = (void | size);
type un3_fc_cast_widen_let = (void | size | str);

@test fn fc_cast_widen_let() void = {
	let v: un16_fc_cast_widen_let = 5: size;
	let w: un3_fc_cast_widen_let = (v: un3_fc_cast_widen_let);
	assert(!(!(w is size)));
	assert(!((w as size) != 5));
};

type un16_fc_unwrap_tagged_let = (void | size);
type err_fc_unwrap_tagged_let = !void;

fn get_fc_unwrap_tagged_let() (un16_fc_unwrap_tagged_let | err_fc_unwrap_tagged_let) = {
	let v: un16_fc_unwrap_tagged_let = 7: size;
	return v;
};

fn use_fc_unwrap_tagged_let() (size | err_fc_unwrap_tagged_let) = {
	let w = get_fc_unwrap_tagged_let()?;
	if (!(w is size)) { return 99; };
	return w as size;
};

@test fn fc_unwrap_tagged_let() void = {
	match (use_fc_unwrap_tagged_let()) {
	case let s: size => { assert(!(s != 7)); };
	case err_fc_unwrap_tagged_let => { assert(false); };
	};
};

type err_fc_unwrap_ident = !void;

fn use_fc_unwrap_ident(v: (size | err_fc_unwrap_ident)) (size | err_fc_unwrap_ident) = {
	let w = v?;
	return w: size;
};

@test fn fc_unwrap_ident() void = {
	let v: (size | err_fc_unwrap_ident) = 7: size;
	match (use_fc_unwrap_ident(v)) {
	case let s: size => { assert(!(s != 7)); };
	case err_fc_unwrap_ident => { assert(false); };
	};
};

type err_fc_unwrap_deref = !void;

fn use_fc_unwrap_deref(p: *(size | err_fc_unwrap_deref)) (size | err_fc_unwrap_deref) = {
	let x = (*p)?;
	return x: size;
};

@test fn fc_unwrap_deref() void = {
	let v: (size | err_fc_unwrap_deref) = 7: size;
	match (use_fc_unwrap_deref(&v)) {
	case let s: size => { assert(!(s != 7)); };
	case err_fc_unwrap_deref => { assert(false); };
	};
};

type un16_fc_cast_deref_arg = (void | size);

fn take_fc_cast_deref_arg(e: un16_fc_cast_deref_arg) size = {
	if (!(e is size)) { return 99; };
	return e as size;
};

@test fn fc_cast_deref_arg() void = {
	let v: un16_fc_cast_deref_arg = 7: size;
	let p: *un16_fc_cast_deref_arg = &v;
	assert(!(take_fc_cast_deref_arg(((*p): un16_fc_cast_deref_arg)) != 7));
};

type un16_fc_deref_void_16 = (void | size);

@test fn fc_deref_void_16() void = {
	let v: un16_fc_deref_void_16 = void;
	let p: *un16_fc_deref_void_16 = &v;
	match (*p) {
	case let s: size => { assert(false); };
	case void => { };
	};
	assert(!((*p) is size));
	let w = *p;
	assert(!(!(w is void)));
};

type un16_fc_deref_slice_elem_16 = (void | size);

@test fn fc_deref_slice_elem_16() void = {
	let xs: []un16_fc_deref_slice_elem_16 = [];
	append(xs, 11: size);
	append(xs, void);
	let p: *un16_fc_deref_slice_elem_16 = &xs[0];
	match (*p) {
	case let s: size => { assert(!(s != 11)); };
	case void => { assert(false); };
	};
	let q: *un16_fc_deref_slice_elem_16 = &xs[1];
	assert(!(!((*q) is void)));
};

type big4_fc_deref_arg_40 = struct { a: u64, b: u64, c: u64, d: u64 };
type un40_fc_deref_arg_40 = (void | big4_fc_deref_arg_40);

fn take_fc_deref_arg_40(e: un40_fc_deref_arg_40) u64 = {
	match (e) {
	case let g: big4_fc_deref_arg_40 => {
		if (g.b != 2u64 || g.c != 3u64) { return 90u64; };
		return g.a + g.d;
	};
	case void => { return 0u64; };
	};
};

@test fn fc_deref_arg_40() void = {
	let v: un40_fc_deref_arg_40 = big4_fc_deref_arg_40 { a = 30u64, b = 2u64, c = 3u64, d = 12u64 };
	let p: *un40_fc_deref_arg_40 = &v;
	assert(!(take_fc_deref_arg_40(*p) != 42u64));
};

type big_fc_deref_arg_56 = struct { a: u64, b: u64, c: u64, d: u64, e: u64, f: u64 };
type un56_fc_deref_arg_56 = (void | big_fc_deref_arg_56);

fn take_fc_deref_arg_56(e: un56_fc_deref_arg_56) u64 = {
	match (e) {
	case let g: big_fc_deref_arg_56 => {
		if (g.b != 2u64 || g.e != 5u64) { return 90u64; };
		return g.a + g.f;
	};
	case void => { return 0u64; };
	};
};

@test fn fc_deref_arg_56() void = {
	let v: un56_fc_deref_arg_56 = big_fc_deref_arg_56 { a = 30u64, b = 2u64, c = 3u64, d = 4u64, e = 5u64, f = 12u64 };
	let p: *un56_fc_deref_arg_56 = &v;
	assert(!(take_fc_deref_arg_56(*p) != 42u64));
};

type un16_fc_arg_balance_multi = (void | size);

fn take_fc_arg_balance_multi(a: size, e: un16_fc_arg_balance_multi, b: size) size = {
	if (a != 100) { return 90; };
	if (!(e is size)) { return 91; };
	if ((e as size) != 7) { return 92; };
	if (b != 200) { return 93; };
	return a + (e as size) + b;
};

@test fn fc_arg_balance_multi() void = {
	let v: un16_fc_arg_balance_multi = 7: size;
	let p: *un16_fc_arg_balance_multi = &v;
	assert(!(take_fc_arg_balance_multi(100, *p, 200) != 307));
	assert(!(take_fc_arg_balance_multi(100, *p, 200) != 307));
};

@test fn t44_inferred_let_cast() void = {
	let t = (4: size, 2: size);
	assert(!(t.0 != 4));
	assert(!(t.1 != 2));
};

@test fn t44_inferred_let_bare() void = {
	let t = (4, 2);
	assert(!(t.0 != 4));
	assert(!(t.1 != 2));
};

@test fn t44_inferred_let_mixed3() void = {
	let t = (4: size, 2, 36: size);
	assert(!(t.0 + t.2 != 40));
	assert(!(t.1 != 2));
};

@test fn t44_inferred_let_float() void = {
	let t = (1.5, 2.5);
	assert(!(t.0 + t.1 != 4.0));
};

@test fn t44_inferred_destructure() void = {
	let t = (40: size, 2: size);
	let (a, b) = t;
	assert(!(a + b != 42));
};

fn add_t44_inferred_arg(t: (size, size)) size = {
	return t.0 + t.1;
};

@test fn t44_inferred_arg() void = {
	let t = (40: size, 2: size);
	assert(!(add_t44_inferred_arg(t) != 42));
};

type un16_t57_ret_cast_elem = (void | size);

fn mk_t57_ret_cast_elem() (un16_t57_ret_cast_elem, size) = {
	return (5: size, 9);
};

@test fn t57_ret_cast_elem() void = {
	let t = mk_t57_ret_cast_elem();
	assert(!(t.1 != 9));
	let (a, b) = mk_t57_ret_cast_elem();
	assert(!(!(a is size)));
	assert(!(a as size != 5));
	assert(!(b != 9));
};

fn mk_t57_ret_inline_union() ((void | size), size) = {
	return (5: size, 9);
};

@test fn t57_ret_inline_union() void = {
	let (a, b) = mk_t57_ret_inline_union();
	assert(!(!(a is size)));
	assert(!(b != 9));
	assert(!(a as size != 5));
};

type un16_t57_let_literal = (void | size);

@test fn t57_let_literal() void = {
	let t: (un16_t57_let_literal, size) = (5: size, 9);
	assert(!(t.1 != 9));
	assert(!(!(t.0 is size)));
	assert(!(t.0 as size != 5));
};

type un16_t57_tagged_second_elem = (void | size);

fn mk2_t57_tagged_second_elem() (size, un16_t57_tagged_second_elem) = {
	return (3, 7: size);
};

@test fn t57_tagged_second_elem() void = {
	let (a, b) = mk2_t57_tagged_second_elem();
	assert(!(a != 3));
	assert(!(!(b is size)));
	assert(!(b as size != 7));
};

type unf_t57_float_payload = (void | f64);

fn mkf_t57_float_payload() (unf_t57_float_payload, size) = {
	return (1.5, 9);
};

@test fn t57_float_payload() void = {
	let (a, b) = mkf_t57_float_payload();
	assert(!(b != 9));
	assert(!(!(a is f64)));
	assert(!(a as f64 != 1.5));
};

type un_t57_tagged_mid_elem = (void | size);

fn mk3_t57_tagged_mid_elem() (size, un_t57_tagged_mid_elem, size) = {
	return (1, 5: size, 9);
};

@test fn t57_tagged_mid_elem() void = {
	let (a, b, c) = mk3_t57_tagged_mid_elem();
	assert(!(a != 1));
	assert(!(!(b is size)));
	assert(!(b as size != 5));
	assert(!(c != 9));
};

type un_t57_two_tagged_void_elem = (void | size);

fn mk_t57_two_tagged_void_elem() (un_t57_two_tagged_void_elem, un_t57_two_tagged_void_elem) = {
	return (5: size, void);
};

@test fn t57_two_tagged_void_elem() void = {
	let t = mk_t57_two_tagged_void_elem();
	assert(!(!(t.0 is size)));
	assert(!(t.0 as size != 5));
	assert(!(!(t.1 is void)));
};

type un_t57_sse_coexist = (void | size);

fn mk_t57_sse_coexist() (f64, un_t57_sse_coexist) = {
	return (0.5, 7: size);
};

@test fn t57_sse_coexist() void = {
	let (x, e) = mk_t57_sse_coexist();
	assert(!(x * 4.0 != 2.0));
	assert(!(!(e is size)));
	assert(!(e as size != 7));
};

type un16_t57_bare_untyped_payload = (void | size);

fn mkb_t57_bare_untyped_payload() (un16_t57_bare_untyped_payload, size) = {
	return (5, 9);
};

@test fn t57_bare_untyped_payload() void = {
	let (a, b) = mkb_t57_bare_untyped_payload();
	assert(!(!(a is size)));
	assert(!(a as size != 5));
	assert(!(b != 9));
};

type un16_t57_ident_no_regress = (void | size);

fn mk_t57_ident_no_regress() (un16_t57_ident_no_regress, size) = {
	let e: un16_t57_ident_no_regress = 5: size;
	return (e, 9);
};

@test fn t57_ident_no_regress() void = {
	let t = mk_t57_ident_no_regress();
	assert(!(t.1 != 9));
	assert(!(!(t.0 is size)));
	assert(!(t.0 as size != 5));
};