Commit fba5c230f043a14e5b73c25add54cd1f2b15ba40 | zig

author	Jacob Young <jacobly@ziglang.org> 2026-06-14 03:58:43-04:00
committer	Jacob Young <jacobly@ziglang.org> 2026-06-20 21:08:23-04:00
log	fba5c230f043a14e5b73c25add54cd1f2b15ba40
tree	e0f25fcebf08a092c9de89380b62077fe3e818ed
parent	4f921814c0a6555a61d9e0a92fcc6f30bc20e994

x86_64: implement win64 abi for more vector types

6 files changed, 30931 insertions(+), 9182 deletions(-)

src
- codegen
  - llvm
    FuncGen.zig
  - x86_64
    CodeGen.zig
    abi.zig
test
- c_abi
  - cfuncs.c
  - main.zig
- tests.zig

src/codegen/llvm/FuncGen.zig+44-12

...	...	@@ -6789,22 +6789,29 @@ const ParamTypeIterator = struct {
6789	6789	return .abi_sized_int;
6790	6790	}
6791	6791	},
6792		.win_i128 => {
	6792	.sse,
	6793	.integer_per_element,
	6794	.sse_per_element,
	6795	.sse_sse_x87_per_qword,
	6796	.sse_per_xword,
	6797	.sse_per_yword,
	6798	.sse_per_zword,
	6799	=> {
6793	6800	it.zig_index += 1;
6794	6801	it.llvm_index += 1;
6795		return .byref;
	6802	return .byval;
6796	6803	},
	6804	.sseup, .x87, .x87up, .none, .float, .float_combine => unreachable,
6797	6805	.memory => {
6798	6806	it.zig_index += 1;
6799	6807	it.llvm_index += 1;
6800	6808	return .byref_mut;
6801	6809	},
6802		.sse => {
	6810	.win_i128 => {
6803	6811	it.zig_index += 1;
6804	6812	it.llvm_index += 1;
6805		return .byval;
	6813	return .byref;
6806	6814	},
6807		else => unreachable,
6808	6815	}
6809	6816	}
6810	6817
...	...	@@ -6867,9 +6874,13 @@ const ParamTypeIterator = struct {
6867	6874	.none => break,
6868	6875	.memory => unreachable, // handled above
6869	6876	.win_i128 => unreachable, // windows only
6870		.integer_per_element => {
6871		@panic("TODO");
6872		},
	6877	.integer_per_element,
	6878	.sse_per_element,
	6879	.sse_sse_x87_per_qword,
	6880	.sse_per_xword,
	6881	.sse_per_yword,
	6882	.sse_per_zword,
	6883	=> unreachable, // vectors already handled by `isScalar` above
6873	6884	}
6874	6885	offset += 8;
6875	6886	}
...	...	@@ -6912,7 +6923,7 @@ pub fn iterateParamTypes(object: *Object, fn_info: InternPool.Key.FuncType) Para
6912	6923	.fn_info = fn_info,
6913	6924	.zig_index = 0,
6914	6925	.llvm_index = 0,
6915		.types_len = 0,
	6926	.types_len = undefined,
6916	6927	.types_buffer = undefined,
6917	6928	.offsets_buffer = undefined,
6918	6929	.byval_attr = false,
...	...	@@ -6979,6 +6990,7 @@ fn firstParamSRetX86Fastcall(zcu: *Zcu, ty: Type) bool {
6979	6990	}
6980	6991
6981	6992	fn firstParamSRetSystemV(ty: Type, zcu: Zcu, target: const std.Target) bool {
	6993	if (isScalar(zcu, ty)) return false;
6982	6994	const class = x86_64_abi.classifySystemV(ty, zcu, target, .ret);
6983	6995	if (class[0] == .memory) return true;
6984	6996	if (class[0] == .x87 and class[2] != .none) return true;
...	...	@@ -7078,10 +7090,23 @@ fn lowerWin64FnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.Err
7078	7090	return o.builder.intType(@intCast(return_type.abiSize(zcu) * 8));
7079	7091	}
7080	7092	},
	7093	.sse,
	7094	.integer_per_element,
	7095	.sse_per_element,
	7096	.sse_sse_x87_per_qword,
	7097	.sse_per_xword,
	7098	.sse_per_yword,
	7099	.sse_per_zword,
	7100	=> return o.lowerType(return_type),
	7101	.sseup,
	7102	.x87,
	7103	.x87up,
	7104	.none,
	7105	.float,
	7106	.float_combine,
	7107	=> unreachable,
7081	7108	.win_i128 => return o.builder.vectorType(.normal, 2, .i64),
7082	7109	.memory => return .void,
7083		.sse => return o.lowerType(return_type),
7084		else => unreachable,
7085	7110	}
7086	7111	}
7087	7112
...	...	@@ -7129,8 +7154,15 @@ fn lowerSystemVFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.E
7129	7154	},
7130	7155	.x87up => continue,
7131	7156	.none => break,
7132		.memory, .integer_per_element => return .void,
	7157	.memory => return .void,
7133	7158	.win_i128 => unreachable, // windows only
	7159	.integer_per_element,
	7160	.sse_per_element,
	7161	.sse_sse_x87_per_qword,
	7162	.sse_per_xword,
	7163	.sse_per_yword,
	7164	.sse_per_zword,
	7165	=> unreachable, // vectors already handled by `isScalar` above
7134	7166	}
7135	7167	}
7136	7168	const first_non_integer = std.mem.indexOfNone(x86_64_abi.Class, &classes, &.{.integer});

src/codegen/x86_64/CodeGen.zig+1127-599

...	...	@@ -169,6 +169,11 @@ const MaskInfo = packed struct {
169	169	scalar: Memory.Size,
170	170	};
171	171
	172	const ArgsInfo = struct {
	173	info: packed struct { reg_index: u3, frame_off: i29 },
	174	frame_index: FrameIndex,
	175	};
	176
172	177	pub const MCValue = union(enum) {
173	178	/// No runtime bits. `void` types, empty structs, u0, enums with 1 tag, etc.
174	179	/// TODO Look into deleting this tag and using `dead` instead, since every use
...	...	@@ -220,8 +225,16 @@ pub const MCValue = union(enum) {
220	225	lea_lazy_sym: link.File.LazySymbol,
221	226	load_extern_func: Mir.NullTerminatedString,
222	227	lea_extern_func: Mir.NullTerminatedString,
223		/// Supports integer_per_element abi
224		elementwise_args: packed struct { regs: u3, frame_off: i29, frame_index: FrameIndex },
	228	/// Supports `integer_per_element` abi
	229	elementwise_gpr: ArgsInfo,
	230	/// Supports `sse_per_element` abi
	231	elementwise_sse: ArgsInfo,
	232	/// Supports `sse_per_xword` abi
	233	xwordwise_sse: ArgsInfo,
	234	/// Supports `sse_per_yword` abi
	235	ywordwise_sse: ArgsInfo,
	236	/// Supports `sse_per_zword` abi
	237	zwordwise_sse: ArgsInfo,
225	238	/// This indicates that we have already allocated a frame index for this instruction,
226	239	/// but it has not been spilled there yet in the current control flow.
227	240	/// Payload is a frame index.
...	...	@@ -248,7 +261,11 @@ pub const MCValue = union(enum) {
248	261	.lea_lazy_sym,
249	262	.lea_extern_func,
250	263	.load_extern_func,
251		.elementwise_args,
	264	.elementwise_gpr,
	265	.elementwise_sse,
	266	.xwordwise_sse,
	267	.ywordwise_sse,
	268	.zwordwise_sse,
252	269	.reserved_frame,
253	270	.air_ref,
254	271	=> false,
...	...	@@ -369,7 +386,11 @@ pub const MCValue = union(enum) {
369	386	.lea_uav,
370	387	.lea_lazy_sym,
371	388	.lea_extern_func,
372		.elementwise_args,
	389	.elementwise_gpr,
	390	.elementwise_sse,
	391	.xwordwise_sse,
	392	.ywordwise_sse,
	393	.zwordwise_sse,
373	394	.reserved_frame,
374	395	.air_ref,
375	396	=> unreachable, // not in memory
...	...	@@ -406,7 +427,11 @@ pub const MCValue = union(enum) {
406	427	.load_uav,
407	428	.load_lazy_sym,
408	429	.load_extern_func,
409		.elementwise_args,
	430	.elementwise_gpr,
	431	.elementwise_sse,
	432	.xwordwise_sse,
	433	.ywordwise_sse,
	434	.zwordwise_sse,
410	435	.reserved_frame,
411	436	.air_ref,
412	437	=> unreachable, // not dereferenceable
...	...	@@ -428,7 +453,11 @@ pub const MCValue = union(enum) {
428	453	.unreach,
429	454	.dead,
430	455	.undef,
431		.elementwise_args,
	456	.elementwise_gpr,
	457	.elementwise_sse,
	458	.xwordwise_sse,
	459	.ywordwise_sse,
	460	.zwordwise_sse,
432	461	.reserved_frame,
433	462	.air_ref,
434	463	=> unreachable, // not valid
...	...	@@ -482,7 +511,11 @@ pub const MCValue = union(enum) {
482	511	.register_mask,
483	512	.indirect_load_frame,
484	513	.lea_frame,
485		.elementwise_args,
	514	.elementwise_gpr,
	515	.elementwise_sse,
	516	.xwordwise_sse,
	517	.ywordwise_sse,
	518	.zwordwise_sse,
486	519	.reserved_frame,
487	520	.lea_nav,
488	521	.lea_uav,
...	...	@@ -560,8 +593,20 @@ pub const MCValue = union(enum) {
560	593	.lea_lazy_sym => \|pl\| try w.print("lazy:{s}:{d}", .{ @tagName(pl.kind), @intFromEnum(pl.ty) }),
561	594	.load_extern_func => \|pl\| try w.print("[extern:{d}]", .{@intFromEnum(pl)}),
562	595	.lea_extern_func => \|pl\| try w.print("extern:{d}", .{@intFromEnum(pl)}),
563		.elementwise_args => \|pl\| try w.print("elementwise:{d}:[{f} + 0x{x}]", .{
564		pl.regs, pl.frame_index, pl.frame_off,
	596	.elementwise_gpr => \|pl\| try w.print("elementwise:gpr{d}:[{f} + 0x{x}]", .{
	597	pl.info.reg_index, pl.frame_index, pl.info.frame_off,
	598	}),
	599	.elementwise_sse => \|pl\| try w.print("elementwise:sse{d}:[{f} + 0x{x}]", .{
	600	pl.info.reg_index, pl.frame_index, pl.info.frame_off,
	601	}),
	602	.xwordwise_sse => \|pl\| try w.print("xwordwise:sse{d}:[{f} + 0x{x}]", .{
	603	pl.info.reg_index, pl.frame_index, pl.info.frame_off,
	604	}),
	605	.ywordwise_sse => \|pl\| try w.print("ywordwise:sse{d}:[{f} + 0x{x}]", .{
	606	pl.info.reg_index, pl.frame_index, pl.info.frame_off,
	607	}),
	608	.zwordwise_sse => \|pl\| try w.print("zwordwise:sse{d}:[{f} + 0x{x}]", .{
	609	pl.info.reg_index, pl.frame_index, pl.info.frame_off,
565	610	}),
566	611	.reserved_frame => \|pl\| try w.print("(dead:{f})", .{pl}),
567	612	.air_ref => \|pl\| try w.print("(air:0x{x})", .{@intFromEnum(pl)}),
...	...	@@ -595,7 +640,11 @@ const InstTracking = struct {
595	640	.lea_extern_func,
596	641	=> result,
597	642	.dead,
598		.elementwise_args,
	643	.elementwise_gpr,
	644	.elementwise_sse,
	645	.xwordwise_sse,
	646	.ywordwise_sse,
	647	.zwordwise_sse,
599	648	.reserved_frame,
600	649	.air_ref,
601	650	=> unreachable,
...	...	@@ -707,7 +756,11 @@ const InstTracking = struct {
707	756	.register_overflow,
708	757	.register_mask,
709	758	.indirect,
710		.elementwise_args,
	759	.elementwise_gpr,
	760	.elementwise_sse,
	761	.xwordwise_sse,
	762	.ywordwise_sse,
	763	.zwordwise_sse,
711	764	.air_ref,
712	765	=> unreachable,
713	766	}
...	...	@@ -789,19 +842,24 @@ const InstTracking = struct {
789	842
790	843	// Disable death.
791	844	var found_reg = false;
792		var remaining_reg: Register = .none;
	845	var remaining_regs: [4]Register = undefined;
	846	var remaining_regs_len: usize = 0;
793	847	for (tracking.getRegs()) \|tracked_reg\| if (tracked_reg.id() == reg.id()) {
794	848	assert(!found_reg);
795	849	found_reg = true;
796	850	} else {
797		assert(remaining_reg == .none);
798		remaining_reg = tracked_reg;
	851	remaining_regs[remaining_regs_len] = tracked_reg;
	852	remaining_regs_len += 1;
799	853	};
800	854	assert(found_reg);
801	855	if (tracking.long == .none) tracking.long = tracking.short;
802		tracking.short = switch (remaining_reg) {
803		.none => .{ .dead = function.scope_generation },
804		else => .{ .register = remaining_reg },
	856	tracking.short = switch (remaining_regs_len) {
	857	0 => .{ .dead = function.scope_generation },
	858	1 => .{ .register = remaining_regs[0] },
	859	2 => .{ .register_pair = remaining_regs[0..2].* },
	860	3 => .{ .register_triple = remaining_regs[0..3].* },
	861	4 => .{ .register_quadruple = remaining_regs[0..4].* },
	862	else => unreachable,
805	863	};
806	864
807	865	// Perform side-effects of freeValue manually.
...	...	@@ -89204,7 +89262,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
89204	89262	var ops = try cg.tempsFromOperands(inst, .{un_op});
89205	89263	while (try ops[0].toBase(false, cg)) {}
89206	89264	try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{
89207		.size = cg.memSize(eu_err_ty),
	89265	.size = cg.memSize(eu_err_ty, .general_purpose),
89208	89266	.disp = eu_err_off,
89209	89267	}), .u(0));
89210	89268	const is_err = try cg.tempInit(.bool, .{ .eflags = .ne });
...	...	@@ -89220,7 +89278,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
89220	89278	var ops = try cg.tempsFromOperands(inst, .{un_op});
89221	89279	while (try ops[0].toBase(false, cg)) {}
89222	89280	try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{
89223		.size = cg.memSize(eu_err_ty),
	89281	.size = cg.memSize(eu_err_ty, .general_purpose),
89224	89282	.disp = eu_err_off,
89225	89283	}), .u(0));
89226	89284	const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e });
...	...	@@ -89236,11 +89294,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
89236	89294	var ops = try cg.tempsFromOperands(inst, .{un_op});
89237	89295	try ops[0].toOffset(eu_err_off, cg);
89238	89296	while (try ops[0].toLea(cg)) {}
89239		try cg.asmMemoryImmediate(
89240		.{ ._, .cmp },
89241		try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = cg.memSize(eu_err_ty) }),
89242		.u(0),
89243		);
	89297	try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.deref().mem(cg, .{
	89298	.size = cg.memSize(eu_err_ty, .general_purpose),
	89299	}), .u(0));
89244	89300	const is_err = try cg.tempInit(.bool, .{ .eflags = .ne });
89245	89301	try is_err.finish(inst, &.{un_op}, &ops, cg);
89246	89302	},
...	...	@@ -89254,11 +89310,9 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
89254	89310	var ops = try cg.tempsFromOperands(inst, .{un_op});
89255	89311	try ops[0].toOffset(eu_err_off, cg);
89256	89312	while (try ops[0].toLea(cg)) {}
89257		try cg.asmMemoryImmediate(
89258		.{ ._, .cmp },
89259		try ops[0].tracking(cg).short.deref().mem(cg, .{ .size = cg.memSize(eu_err_ty) }),
89260		.u(0),
89261		);
	89313	try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.deref().mem(cg, .{
	89314	.size = cg.memSize(eu_err_ty, .general_purpose),
	89315	}), .u(0));
89262	89316	const is_non_err = try cg.tempInit(.bool, .{ .eflags = .e });
89263	89317	try is_non_err.finish(inst, &.{un_op}, &ops, cg);
89264	89318	},
...	...	@@ -174463,7 +174517,11 @@ fn load(self: *CodeGen, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerE
174463	174517	.register_overflow,
174464	174518	.register_mask,
174465	174519	.indirect_load_frame,
174466		.elementwise_args,
	174520	.elementwise_gpr,
	174521	.elementwise_sse,
	174522	.xwordwise_sse,
	174523	.ywordwise_sse,
	174524	.zwordwise_sse,
174467	174525	.reserved_frame,
174468	174526	=> unreachable, // not a valid pointer
174469	174527	.immediate,
...	...	@@ -174516,7 +174574,11 @@ fn store(
174516	174574	.register_overflow,
174517	174575	.register_mask,
174518	174576	.indirect_load_frame,
174519		.elementwise_args,
	174577	.elementwise_gpr,
	174578	.elementwise_sse,
	174579	.xwordwise_sse,
	174580	.ywordwise_sse,
	174581	.zwordwise_sse,
174520	174582	.reserved_frame,
174521	174583	=> unreachable, // not a valid pointer
174522	174584	.immediate,
...	...	@@ -174566,7 +174628,11 @@ fn genUnOpMir(self: *CodeGen, mir_tag: Mir.Inst.FixedTag, dst_ty: Type, dst_mcv:
174566	174628	.lea_uav,
174567	174629	.lea_lazy_sym,
174568	174630	.lea_extern_func,
174569		.elementwise_args,
	174631	.elementwise_gpr,
	174632	.elementwise_sse,
	174633	.xwordwise_sse,
	174634	.ywordwise_sse,
	174635	.zwordwise_sse,
174570	174636	.reserved_frame,
174571	174637	.air_ref,
174572	174638	=> unreachable, // unmodifiable destination
...	...	@@ -175256,7 +175322,11 @@ fn genBinOpMir(
175256	175322	.lea_lazy_sym,
175257	175323	.lea_extern_func,
175258	175324	.indirect_load_frame,
175259		.elementwise_args,
	175325	.elementwise_gpr,
	175326	.elementwise_sse,
	175327	.xwordwise_sse,
	175328	.ywordwise_sse,
	175329	.zwordwise_sse,
175260	175330	.reserved_frame,
175261	175331	.air_ref,
175262	175332	=> unreachable, // unmodifiable destination
...	...	@@ -175293,7 +175363,11 @@ fn genBinOpMir(
175293	175363	.register_overflow,
175294	175364	.register_mask,
175295	175365	.indirect_load_frame,
175296		.elementwise_args,
	175366	.elementwise_gpr,
	175367	.elementwise_sse,
	175368	.xwordwise_sse,
	175369	.ywordwise_sse,
	175370	.zwordwise_sse,
175297	175371	.reserved_frame,
175298	175372	=> unreachable,
175299	175373	.register,
...	...	@@ -175465,7 +175539,11 @@ fn genBinOpMir(
175465	175539	.register_overflow,
175466	175540	.register_mask,
175467	175541	.indirect_load_frame,
175468		.elementwise_args,
	175542	.elementwise_gpr,
	175543	.elementwise_sse,
	175544	.xwordwise_sse,
	175545	.ywordwise_sse,
	175546	.zwordwise_sse,
175469	175547	.reserved_frame,
175470	175548	.air_ref,
175471	175549	=> unreachable,
...	...	@@ -175569,7 +175647,11 @@ fn genBinOpMir(
175569	175647	.register_overflow,
175570	175648	.register_mask,
175571	175649	.indirect_load_frame,
175572		.elementwise_args,
	175650	.elementwise_gpr,
	175651	.elementwise_sse,
	175652	.xwordwise_sse,
	175653	.ywordwise_sse,
	175654	.zwordwise_sse,
175573	175655	.reserved_frame,
175574	175656	.air_ref,
175575	175657	=> unreachable,
...	...	@@ -175683,120 +175765,233 @@ fn genBinOpMir(
175683	175765	}
175684	175766	}
175685	175767
175686		fn airArg(self: *CodeGen, inst: Air.Inst.Index) !void {
175687		const zcu = self.pt.zcu;
175688		const arg_index = for (self.args, 0..) \|arg, arg_index\| {
	175768	fn airArg(cg: *CodeGen, inst: Air.Inst.Index) !void {
	175769	const zcu = cg.pt.zcu;
	175770	const arg_index = for (cg.args, 0..) \|arg, arg_index\| {
175689	175771	if (arg != .none) break arg_index;
175690	175772	} else unreachable;
175691		const src_mcv = self.args[arg_index];
175692		self.args = self.args[arg_index + 1 ..];
175693		const result: MCValue = if (self.mod.strip and self.liveness.isUnused(inst)) .unreach else result: {
175694		const arg_ty = self.typeOfIndex(inst);
	175773	const src_mcv = cg.args[arg_index];
	175774	cg.args = cg.args[arg_index + 1 ..];
	175775	const result: MCValue = if (cg.mod.strip and cg.liveness.isUnused(inst)) .unreach else result: {
	175776	const arg_ty = cg.typeOfIndex(inst);
175695	175777	switch (src_mcv) {
175696	175778	.register, .register_pair, .load_frame => {
175697		for (src_mcv.getRegs()) \|reg\| self.register_manager.getRegAssumeFree(reg, inst);
	175779	for (src_mcv.getRegs()) \|reg\| cg.register_manager.getRegAssumeFree(reg, inst);
175698	175780	break :result src_mcv;
175699	175781	},
175700	175782	.indirect => \|reg_off\| {
175701		self.register_manager.getRegAssumeFree(reg_off.reg, null);
175702		const dst_mcv = try self.allocRegOrMem(inst, false);
175703		try self.genCopy(arg_ty, dst_mcv, src_mcv, .{});
	175783	cg.register_manager.getRegAssumeFree(reg_off.reg, null);
	175784	const dst_mcv = try cg.allocRegOrMem(inst, false);
	175785	try cg.genCopy(arg_ty, dst_mcv, src_mcv, .{});
175704	175786	break :result dst_mcv;
175705	175787	},
175706	175788	.indirect_load_frame => \|frame_addr\| {
175707		const dst_mcv = try self.allocRegOrMem(inst, false);
175708		const ptr_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
175709		const ptr_lock = self.register_manager.lockRegAssumeUnused(ptr_reg);
175710		defer self.register_manager.unlockReg(ptr_lock);
175711		try self.genSetReg(ptr_reg, .usize, .{ .load_frame = frame_addr }, .{});
175712		try self.genCopy(arg_ty, dst_mcv, .{ .indirect = .{ .reg = ptr_reg } }, .{});
	175789	const dst_mcv = try cg.allocRegOrMem(inst, false);
	175790	const ptr_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp);
	175791	const ptr_lock = cg.register_manager.lockRegAssumeUnused(ptr_reg);
	175792	defer cg.register_manager.unlockReg(ptr_lock);
	175793	try cg.genSetReg(ptr_reg, .usize, .{ .load_frame = frame_addr }, .{});
	175794	try cg.genCopy(arg_ty, dst_mcv, .{ .indirect = .{ .reg = ptr_reg } }, .{});
175713	175795	break :result dst_mcv;
175714	175796	},
175715		.elementwise_args => \|regs_frame_addr\| {
175716		try self.spillEflagsIfOccupied();
	175797	.elementwise_gpr, .elementwise_sse => \|regs_frame_addr\| {
	175798	const fn_info = zcu.typeToFunc(cg.fn_type).?;
	175799	const elem_ty = arg_ty.childType(zcu);
	175800	const elem_rc: Register.Class, const param_regs = switch (src_mcv) {
	175801	else => unreachable,
	175802	.elementwise_gpr => .{ .general_purpose, abi.getCAbiIntParamRegs(fn_info.cc) },
	175803	.elementwise_sse => .{ .sse, abi.getCAbiSseParamRegs(fn_info.cc, cg.target) },
	175804	};
	175805	const len = arg_ty.vectorLen(zcu);
	175806	const param_reg_len: u31 =
	175807	@intCast(@min(param_regs.len - regs_frame_addr.info.reg_index, len));
175717	175808
175718		const fn_info = zcu.typeToFunc(self.fn_type).?;
175719		const param_int_regs = abi.getCAbiIntParamRegs(fn_info.cc);
175720		var prev_reg: Register = undefined;
175721		for (
175722		param_int_regs[param_int_regs.len - regs_frame_addr.regs ..],
175723		0..,
175724		) \|dst_reg, elem_index\| {
175725		assert(self.register_manager.isRegFree(dst_reg));
175726		if (elem_index > 0) {
175727		try self.asmRegisterImmediate(.{ ._l, .sh }, dst_reg.to8(), .u(elem_index));
175728		try self.asmRegisterRegister(
175729		.{ ._, .@"or" },
175730		dst_reg.to8(),
175731		prev_reg.to8(),
	175809	const elem_size = cg.memSize(elem_ty, .general_purpose);
	175810	const elem_abi_size = @divExact(elem_size.bitSize(cg.target), 8);
	175811	const strat = if (elem_ty.toIntern() == .bool_type) strat: {
	175812	try cg.spillEflagsIfOccupied();
	175813	break :strat undefined;
	175814	} else try cg.moveStrategy(elem_ty, elem_rc, true);
	175815
	175816	const dst_mcv = try cg.allocRegOrMem(inst, false);
	175817	{
	175818	var prev_reg: Register = undefined;
	175819	for (
	175820	param_regs[regs_frame_addr.info.reg_index..][0..param_reg_len],
	175821	0..,
	175822	) \|src_reg, elem_index\| {
	175823	assert(cg.register_manager.isRegFree(src_reg));
	175824	if (elem_ty.toIntern() == .bool_type) {
	175825	if (elem_index > 0) {
	175826	try cg.asmRegisterImmediate(
	175827	.{ ._l, .sh },
	175828	src_reg.to8(),
	175829	.u(elem_index),
	175830	);
	175831	try cg.asmRegisterRegister(
	175832	.{ ._, .@"or" },
	175833	src_reg.to8(),
	175834	prev_reg.to8(),
	175835	);
	175836	}
	175837	prev_reg = src_reg;
	175838	} else try strat.write(cg, try dst_mcv.mem(cg, .{
	175839	.size = elem_size,
	175840	.disp = @intCast(elem_abi_size * elem_index),
	175841	}), src_reg.toSize(elem_size, cg.target));
	175842	}
	175843	if (elem_ty.toIntern() == .bool_type) {
	175844	if (param_reg_len > 0) {
	175845	const prev_lock = cg.register_manager.lockRegAssumeUnused(prev_reg);
	175846	defer cg.register_manager.unlockReg(prev_lock);
	175847	try cg.asmMemoryRegister(
	175848	.{ ._, .mov },
	175849	try dst_mcv.mem(cg, .{ .size = .byte }),
	175850	prev_reg.to8(),
	175851	);
	175852	}
	175853	const clear_len = arg_ty.abiSize(zcu) - @intFromBool(param_reg_len > 0);
	175854	if (clear_len > 0) try cg.genInlineMemset(
	175855	dst_mcv.address().offset(@intFromBool(param_reg_len > 0)),
	175856	.{ .immediate = 0 },
	175857	.{ .immediate = clear_len },
	175858	.{},
	175859	);
	175860	}
	175861	}
	175862	if (len - param_reg_len > 0) {
	175863	const index_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp);
	175864	const index_lock = cg.register_manager.lockRegAssumeUnused(index_reg);
	175865	defer cg.register_manager.unlockReg(index_lock);
	175866	try cg.asmRegisterImmediate(.{ ._, .mov }, index_reg.to32(), .u(param_reg_len));
	175867
	175868	const loop: Mir.Inst.Index = @intCast(cg.mir_instructions.len);
	175869	if (elem_ty.toIntern() == .bool_type) {
	175870	try cg.asmMemoryImmediate(.{ ._, .cmp }, .{
	175871	.base = .{ .frame = regs_frame_addr.frame_index },
	175872	.mod = .{ .rm = .{
	175873	.size = .byte,
	175874	.index = index_reg.to64(),
	175875	.scale = .@"8",
	175876	.disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_reg_len,
	175877	} },
	175878	}, Immediate.u(0));
	175879	const unset = try cg.asmJccReloc(.e, undefined);
	175880	try cg.asmMemoryRegister(
	175881	.{ ._s, .bt },
	175882	try dst_mcv.mem(cg, .{ .size = .dword }),
	175883	index_reg.to32(),
175732	175884	);
	175885	cg.performReloc(unset);
	175886	} else {
	175887	const elem_reg =
	175888	try cg.register_manager.allocReg(null, regSetForRegClass(elem_rc));
	175889	const elem_lock = cg.register_manager.lockRegAssumeUnused(elem_reg);
	175890	defer cg.register_manager.unlockReg(elem_lock);
	175891
	175892	try strat.read(cg, elem_reg.toSize(elem_size, cg.target), .{
	175893	.base = .{ .frame = regs_frame_addr.frame_index },
	175894	.mod = .{ .rm = .{
	175895	.size = elem_size,
	175896	.index = index_reg.to64(),
	175897	.scale = .@"8",
	175898	.disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_reg_len,
	175899	} },
	175900	});
	175901	try strat.write(cg, try dst_mcv.mem(cg, .{
	175902	.size = elem_size,
	175903	.index = index_reg.to64(),
	175904	.scale = .fromFactor(@intCast(elem_abi_size)),
	175905	}), elem_reg.toSize(elem_size, cg.target));
175733	175906	}
175734		prev_reg = dst_reg;
	175907	if (cg.hasFeature(.slow_incdec)) {
	175908	try cg.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(1));
	175909	} else {
	175910	try cg.asmRegister(.{ ._c, .in }, index_reg.to32());
	175911	}
	175912	try cg.asmRegisterImmediate(.{ ._, .cmp }, index_reg.to32(), .u(len));
	175913	_ = try cg.asmJccReloc(.b, loop);
175735	175914	}
175736	175915
175737		const prev_lock = if (regs_frame_addr.regs > 0)
175738		self.register_manager.lockRegAssumeUnused(prev_reg)
175739		else
175740		null;
175741		defer if (prev_lock) \|lock\| self.register_manager.unlockReg(lock);
	175916	break :result dst_mcv;
	175917	},
	175918	.xwordwise_sse, .ywordwise_sse, .zwordwise_sse => \|regs_frame_addr\| {
	175919	const fn_info = zcu.typeToFunc(cg.fn_type).?;
	175920	const elem_size: Memory.Size, const elem_ty: Type = switch (src_mcv) {
	175921	else => unreachable,
	175922	.xwordwise_sse => .{ .xword, .vector_16_u8 },
	175923	.ywordwise_sse => .{ .yword, .vector_32_u8 },
	175924	.zwordwise_sse => .{ .zword, .vector_64_u8 },
	175925	};
	175926	const elem_abi_size: u31 = @intCast(@divExact(elem_size.bitSize(cg.target), 8));
	175927	const strat = try cg.moveStrategy(elem_ty, .sse, true);
175742	175928
175743		const dst_mcv = try self.allocRegOrMem(inst, false);
175744		if (regs_frame_addr.regs > 0) try self.asmMemoryRegister(
175745		.{ ._, .mov },
175746		try dst_mcv.mem(self, .{ .size = .byte }),
175747		prev_reg.to8(),
175748		);
175749		try self.genInlineMemset(
175750		dst_mcv.address().offset(@intFromBool(regs_frame_addr.regs > 0)),
175751		.{ .immediate = 0 },
175752		.{ .immediate = arg_ty.abiSize(zcu) - @intFromBool(regs_frame_addr.regs > 0) },
175753		.{},
175754		);
	175929	const param_gpr_regs = abi.getCAbiIntParamRegs(fn_info.cc);
	175930	const len = @divExact(arg_ty.abiSize(zcu), elem_abi_size);
	175931	const param_gpr_len: u31 =
	175932	@intCast(@min(param_gpr_regs.len - regs_frame_addr.info.reg_index, len));
175755	175933
175756		const index_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
175757		const index_lock = self.register_manager.lockRegAssumeUnused(index_reg);
175758		defer self.register_manager.unlockReg(index_lock);
	175934	const part_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.sse);
	175935	const part_lock = cg.register_manager.lockRegAssumeUnused(part_reg);
	175936	defer cg.register_manager.unlockReg(part_lock);
	175937	const part_alias = part_reg.toSize(elem_size, cg.target);
175759	175938
175760		try self.asmRegisterImmediate(
175761		.{ ._, .mov },
175762		index_reg.to32(),
175763		.u(regs_frame_addr.regs),
175764		);
175765		const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
175766		try self.asmMemoryImmediate(.{ ._, .cmp }, .{
175767		.base = .{ .frame = regs_frame_addr.frame_index },
175768		.mod = .{ .rm = .{
175769		.size = .byte,
175770		.index = index_reg.to64(),
175771		.scale = .@"8",
175772		.disp = regs_frame_addr.frame_off - @as(u6, regs_frame_addr.regs) * 8,
175773		} },
175774		}, Immediate.u(0));
175775		const unset = try self.asmJccReloc(.e, undefined);
175776		try self.asmMemoryRegister(
175777		.{ ._s, .bt },
175778		try dst_mcv.mem(self, .{ .size = .dword }),
175779		index_reg.to32(),
175780		);
175781		self.performReloc(unset);
175782		if (self.hasFeature(.slow_incdec)) {
175783		try self.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(1));
175784		} else {
175785		try self.asmRegister(.{ ._c, .in }, index_reg.to32());
	175939	const dst_mcv = try cg.allocRegOrMem(inst, false);
	175940
	175941	var arg_offset: u31 = 0;
	175942	for (param_gpr_regs[regs_frame_addr.info.reg_index..][0..param_gpr_len]) \|src_reg\| {
	175943	try strat.read(cg, part_alias, .{
	175944	.base = .{ .reg = src_reg },
	175945	.mod = .{ .rm = .{ .size = elem_size } },
	175946	});
	175947	try strat.write(cg, try dst_mcv.mem(cg, .{
	175948	.size = elem_size,
	175949	.disp = arg_offset,
	175950	}), part_alias);
	175951	arg_offset += elem_abi_size;
	175952	}
	175953
	175954	if (len - param_gpr_len > 0) {
	175955	const index_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp);
	175956	const index_lock = cg.register_manager.lockRegAssumeUnused(index_reg);
	175957	defer cg.register_manager.unlockReg(index_lock);
	175958	try cg.asmRegisterImmediate(.{ ._, .mov }, index_reg.to32(), .u(8 * param_gpr_len));
	175959
	175960	const loop: Mir.Inst.Index = @intCast(cg.mir_instructions.len);
	175961	{
	175962	const ptr_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp);
	175963	const ptr_lock = cg.register_manager.lockRegAssumeUnused(ptr_reg);
	175964	defer cg.register_manager.unlockReg(ptr_lock);
	175965
	175966	try cg.asmRegisterMemory(.{ ._, .mov }, ptr_reg.to64(), .{
	175967	.base = .{ .frame = regs_frame_addr.frame_index },
	175968	.mod = .{ .rm = .{
	175969	.size = .ptr,
	175970	.index = index_reg.to64(),
	175971	.disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_gpr_len,
	175972	} },
	175973	});
	175974	try strat.read(cg, part_alias, .{
	175975	.base = .{ .reg = ptr_reg },
	175976	.mod = .{ .rm = .{ .size = elem_size } },
	175977	});
	175978	try strat.write(cg, try dst_mcv.mem(cg, .{
	175979	.size = elem_size,
	175980	.index = index_reg.to64(),
	175981	.scale = .fromFactor(@intCast(@divExact(elem_abi_size, 8))),
	175982	}), part_alias);
	175983	}
	175984	try cg.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(8));
	175985	try cg.asmRegisterImmediate(.{ ._, .cmp }, index_reg.to32(), .u(8 * len));
	175986	_ = try cg.asmJccReloc(.b, loop);
175786	175987	}
175787		try self.asmRegisterImmediate(
175788		.{ ._, .cmp },
175789		index_reg.to32(),
175790		.u(arg_ty.vectorLen(zcu)),
175791		);
175792		_ = try self.asmJccReloc(.b, loop);
175793	175988
175794	175989	break :result dst_mcv;
175795	175990	},
175796		else => return self.fail("TODO implement arg for {f}", .{src_mcv}),
	175991	else => return cg.fail("TODO implement arg for {f}", .{src_mcv}),
175797	175992	}
175798	175993	};
175799		return self.finishAir(inst, result, .{ .none, .none, .none });
	175994	return cg.finishAir(inst, result, .{ .none, .none, .none });
175800	175995	}
175801	175996
175802	175997	fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue) !void {
...	...	@@ -175804,7 +175999,17 @@ fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue
175804	175999	_ = switch (air_tag) {
175805	176000	else => unreachable,
175806	176001	.arg, .dbg_var_val, .dbg_arg_inline => switch (mcv) {
175807		.none, .unreach, .dead, .elementwise_args, .reserved_frame, .air_ref => unreachable,
	176002	.none,
	176003	.unreach,
	176004	.dead,
	176005	.elementwise_gpr,
	176006	.elementwise_sse,
	176007	.xwordwise_sse,
	176008	.ywordwise_sse,
	176009	.zwordwise_sse,
	176010	.reserved_frame,
	176011	.air_ref,
	176012	=> unreachable,
175808	176013	.immediate => \|imm\| if (std.math.cast(u32, imm)) \|small\| try cg.addInst(.{
175809	176014	.tag = .pseudo,
175810	176015	.ops = switch (air_tag) {
...	...	@@ -175852,7 +176057,17 @@ fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue
175852	176057	},
175853	176058	.dbg_var_ptr => switch (mcv) {
175854	176059	else => unreachable,
175855		.none, .unreach, .dead, .elementwise_args, .reserved_frame, .air_ref => unreachable,
	176060	.none,
	176061	.unreach,
	176062	.dead,
	176063	.elementwise_gpr,
	176064	.elementwise_sse,
	176065	.xwordwise_sse,
	176066	.ywordwise_sse,
	176067	.zwordwise_sse,
	176068	.reserved_frame,
	176069	.air_ref,
	176070	=> unreachable,
175856	176071	.lea_frame => \|frame_addr\| try cg.addInst(.{
175857	176072	.tag = .pseudo,
175858	176073	.ops = .pseudo_dbg_var_m,
...	...	@@ -175910,10 +176125,10 @@ fn genLocalDebugInfo(cg: *CodeGen, air_tag: Air.Inst.Tag, ty: Type, mcv: MCValue
175910	176125	};
175911	176126	}
175912	176127
175913		fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier, opts: CopyOptions) !void {
175914		if (modifier == .always_tail) return self.fail("TODO implement tail calls for x86_64", .{});
	176128	fn airCall(cg: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier, opts: CopyOptions) !void {
	176129	if (modifier == .always_tail) return cg.fail("TODO implement tail calls for x86_64", .{});
175915	176130
175916		const call = self.air.unwrapCall(inst);
	176131	const call = cg.air.unwrapCall(inst);
175917	176132	const arg_refs = call.args;
175918	176133
175919	176134	const ExpectedContents = extern struct {
...	...	@@ -175921,28 +176136,28 @@ fn airCall(self: *CodeGen, inst: Air.Inst.Index, modifier: std.lang.CallModifier
175921	176136	vals: [32][@sizeOf(MCValue)]u8 align(@alignOf(MCValue)),
175922	176137	};
175923	176138	var bfa_buf: [1]ExpectedContents = undefined;
175924		var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), self.gpa);
	176139	var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), cg.gpa);
175925	176140	const allocator = bfa.allocator();
175926	176141
175927	176142	const arg_tys = try allocator.alloc(Type, arg_refs.len);
175928	176143	defer allocator.free(arg_tys);
175929		for (arg_tys, arg_refs) \|arg_ty, arg_ref\| arg_ty. = self.typeOf(arg_ref);
	176144	for (arg_tys, arg_refs) \|arg_ty, arg_ref\| arg_ty. = cg.typeOf(arg_ref);
175930	176145
175931	176146	const arg_vals = try allocator.alloc(MCValue, arg_refs.len);
175932	176147	defer allocator.free(arg_vals);
175933	176148	for (arg_vals, arg_refs) \|arg_val, arg_ref\| arg_val. = .{ .air_ref = arg_ref };
175934	176149
175935		const ret = try self.genCall(.{ .air = call.callee }, arg_tys, arg_vals, opts);
	176150	const ret = try cg.genCall(.{ .air = call.callee }, arg_tys, arg_vals, opts);
175936	176151
175937		var bt = self.liveness.iterateBigTomb(inst);
175938		try self.feed(&bt, call.callee);
175939		for (arg_refs) \|arg_ref\| try self.feed(&bt, arg_ref);
	176152	var bt = cg.liveness.iterateBigTomb(inst);
	176153	try cg.feed(&bt, call.callee);
	176154	for (arg_refs) \|arg_ref\| try cg.feed(&bt, arg_ref);
175940	176155
175941		const result = if (self.liveness.isUnused(inst)) .unreach else ret;
175942		return self.finishAirResult(inst, result);
	176156	const result = if (cg.liveness.isUnused(inst)) .unreach else ret;
	176157	return cg.finishAirResult(inst, result);
175943	176158	}
175944	176159
175945		fn genCall(self: *CodeGen, info: union(enum) {
	176160	fn genCall(cg: *CodeGen, info: union(enum) {
175946	176161	air: Air.Inst.Ref,
175947	176162	extern_func: struct {
175948	176163	return_type: InternPool.Index,
...	...	@@ -175950,13 +176165,13 @@ fn genCall(self: *CodeGen, info: union(enum) {
175950	176165	sym: []const u8,
175951	176166	},
175952	176167	}, arg_types: []const Type, args: []const MCValue, opts: CopyOptions) !MCValue {
175953		const pt = self.pt;
	176168	const pt = cg.pt;
175954	176169	const zcu = pt.zcu;
175955	176170	const ip = &zcu.intern_pool;
175956	176171
175957	176172	const fn_ty = switch (info) {
175958	176173	.air => \|callee\| fn_info: {
175959		const callee_ty = self.typeOf(callee);
	176174	const callee_ty = cg.typeOf(callee);
175960	176175	break :fn_info switch (callee_ty.zigTypeTag(zcu)) {
175961	176176	.@"fn" => callee_ty,
175962	176177	.pointer => callee_ty.childType(zcu),
...	...	@@ -175966,7 +176181,7 @@ fn genCall(self: *CodeGen, info: union(enum) {
175966	176181	.extern_func => \|extern_func\| try pt.funcType(.{
175967	176182	.param_types = extern_func.param_types,
175968	176183	.return_type = extern_func.return_type,
175969		.cc = self.target.cCallingConvention().?,
	176184	.cc = cg.target.cCallingConvention().?,
175970	176185	}),
175971	176186	};
175972	176187	const fn_info = zcu.typeToFunc(fn_ty).?;
...	...	@@ -175977,7 +176192,7 @@ fn genCall(self: *CodeGen, info: union(enum) {
175977	176192	reg_locks: [32][@sizeOf(?RegisterLock)]u8 align(@alignOf(?RegisterLock)),
175978	176193	};
175979	176194	var bfa_buf: ExpectedContents = undefined;
175980		var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), self.gpa);
	176195	var bfa: std.heap.BufferFirstAllocator = .init(@ptrCast(&bfa_buf), cg.gpa);
175981	176196	const allocator = bfa.allocator();
175982	176197
175983	176198	const var_args = try allocator.alloc(Type, args.len - fn_info.param_types.len);
...	...	@@ -175990,10 +176205,10 @@ fn genCall(self: *CodeGen, info: union(enum) {
175990	176205	var reg_locks: std.array_list.Managed(?RegisterLock) = .init(allocator);
175991	176206	defer reg_locks.deinit();
175992	176207	try reg_locks.ensureTotalCapacity(16);
175993		defer for (reg_locks.items) \|reg_lock\| if (reg_lock) \|lock\| self.register_manager.unlockReg(lock);
	176208	defer for (reg_locks.items) \|reg_lock\| if (reg_lock) \|lock\| cg.register_manager.unlockReg(lock);
175994	176209
175995		var call_info = try self.resolveCallingConventionValues(fn_info, var_args, .call_frame);
175996		defer call_info.deinit(self);
	176210	var call_info = try cg.resolveCallingConventionValues(fn_info, var_args, .call_frame);
	176211	defer call_info.deinit(cg);
175997	176212
175998	176213	// We need a properly aligned and sized call frame to be able to call this function.
175999	176214	{
...	...	@@ -176001,7 +176216,7 @@ fn genCall(self: *CodeGen, info: union(enum) {
176001	176216	.size = call_info.stack_byte_count,
176002	176217	.alignment = call_info.stack_align,
176003	176218	});
176004		const frame_allocs_slice = self.frame_allocs.slice();
	176219	const frame_allocs_slice = cg.frame_allocs.slice();
176005	176220	const stack_frame_size =
176006	176221	&frame_allocs_slice.items(.abi_size)[@intFromEnum(FrameIndex.call_frame)];
176007	176222	stack_frame_size.* = @max(stack_frame_size.*, needed_call_frame.abi_size);
...	...	@@ -176010,22 +176225,22 @@ fn genCall(self: *CodeGen, info: union(enum) {
176010	176225	stack_frame_align.* = stack_frame_align.max(needed_call_frame.abi_align);
176011	176226	}
176012	176227
176013		try self.spillEflagsIfOccupied();
176014		try self.spillCallerPreservedRegs(fn_info.cc, call_info.err_ret_trace_reg);
	176228	try cg.spillEflagsIfOccupied();
	176229	try cg.spillCallerPreservedRegs(fn_info.cc, call_info.err_ret_trace_reg);
176015	176230
176016	176231	// set stack arguments first because this can clobber registers
176017	176232	// also clobber spill arguments as we go
176018	176233	switch (call_info.return_value.long) {
176019	176234	.none, .unreach => {},
176020		.indirect => \|reg_off\| try self.register_manager.getReg(reg_off.reg, null),
	176235	.indirect => \|reg_off\| try cg.register_manager.getReg(reg_off.reg, null),
176021	176236	else => unreachable,
176022	176237	}
176023	176238	for (call_info.args, arg_types, args, frame_indices, 0..) \|dst_arg, arg_ty, src_arg, *frame_index, arg_i\|
176024	176239	switch (dst_arg) {
176025	176240	.none => {},
176026	176241	.register => \|reg\| {
176027		try self.register_manager.getReg(reg, null);
176028		try reg_locks.append(self.register_manager.lockReg(reg));
	176242	try cg.register_manager.getReg(reg, null);
	176243	try reg_locks.append(cg.register_manager.lockReg(reg));
176029	176244
176030	176245	if (fn_info.is_var_args and
176031	176246	fn_info.cc == .x86_64_win and
...	...	@@ -176034,88 +176249,166 @@ fn genCall(self: *CodeGen, info: union(enum) {
176034	176249	{
176035	176250	// Floating point arguments must be duplicated into the equivalent integer registers on this ABI
176036	176251	const int_reg = abi.Win64.c_abi_int_param_regs[arg_i];
176037		try reg_locks.append(self.register_manager.lockReg(int_reg));
	176252	try reg_locks.append(cg.register_manager.lockReg(int_reg));
176038	176253	}
176039	176254	},
176040	176255	.register_pair => \|regs\| {
176041		for (regs) \|reg\| try self.register_manager.getReg(reg, null);
176042		try reg_locks.appendSlice(&self.register_manager.lockRegs(2, regs));
	176256	for (regs) \|reg\| try cg.register_manager.getReg(reg, null);
	176257	try reg_locks.appendSlice(&cg.register_manager.lockRegs(2, regs));
176043	176258	},
176044	176259	.indirect => \|reg_off\| {
176045		frame_index.* = try self.allocFrameIndex(.initType(arg_ty, zcu));
176046		try self.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts);
176047		try self.register_manager.getReg(reg_off.reg, null);
176048		try reg_locks.append(self.register_manager.lockReg(reg_off.reg));
	176260	frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu));
	176261	try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts);
	176262	try cg.register_manager.getReg(reg_off.reg, null);
	176263	try reg_locks.append(cg.register_manager.lockReg(reg_off.reg));
	176264	},
	176265	.indirect_load_frame => \|frame_addr\| {
	176266	frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu));
	176267	try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts);
	176268	try cg.genSetMem(
	176269	.{ .frame = frame_addr.index },
	176270	frame_addr.off,
	176271	.usize,
	176272	.{ .lea_frame = .{ .index = frame_index.* } },
	176273	opts,
	176274	);
176049	176275	},
176050	176276	.load_frame => {
176051		try self.genCopy(arg_ty, dst_arg, src_arg, opts);
176052		try self.freeValue(src_arg, .{});
	176277	try cg.genCopy(arg_ty, dst_arg, src_arg, opts);
	176278	try cg.freeValue(src_arg, .{});
176053	176279	},
176054		.elementwise_args => \|regs_frame_addr\| {
176055		const index_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
176056		const index_lock = self.register_manager.lockRegAssumeUnused(index_reg);
176057		defer self.register_manager.unlockReg(index_lock);
176058
176059		const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(self, .{ .size = .dword }) else .{
176060		.base = .{ .reg = try self.copyToTmpRegister(.usize, switch (src_arg) {
	176280	.elementwise_gpr, .elementwise_sse => \|regs_frame_addr\| {
	176281	const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(cg, .{ .size = .dword }) else .{
	176282	.base = .{ .reg = try cg.copyToTmpRegister(.usize, switch (src_arg) {
176061	176283	else => src_arg,
176062		.air_ref => \|src_ref\| try self.resolveInst(src_ref),
	176284	.air_ref => \|src_ref\| try cg.resolveInst(src_ref),
176063	176285	}.address()) },
176064	176286	.mod = .{ .rm = .{ .size = .dword } },
176065	176287	};
176066	176288	const src_lock = switch (src_mem.base) {
176067		.reg => \|src_reg\| self.register_manager.lockReg(src_reg),
	176289	.reg => \|src_reg\| cg.register_manager.lockReg(src_reg),
176068	176290	else => null,
176069	176291	};
176070		defer if (src_lock) \|lock\| self.register_manager.unlockReg(lock);
	176292	defer if (src_lock) \|lock\| cg.register_manager.unlockReg(lock);
176071	176293
176072		try self.asmRegisterImmediate(
176073		.{ ._, .mov },
176074		index_reg.to32(),
176075		.u(regs_frame_addr.regs),
176076		);
176077		const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
176078		try self.asmMemoryRegister(.{ ._, .bt }, src_mem, index_reg.to32());
176079		try self.asmSetccMemory(.c, .{
176080		.base = .{ .frame = regs_frame_addr.frame_index },
176081		.mod = .{ .rm = .{
176082		.size = .byte,
176083		.index = index_reg.to64(),
176084		.scale = .@"8",
176085		.disp = regs_frame_addr.frame_off - @as(u6, regs_frame_addr.regs) * 8,
176086		} },
176087		});
176088		if (self.hasFeature(.slow_incdec)) {
176089		try self.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(1));
176090		} else {
176091		try self.asmRegister(.{ ._c, .in }, index_reg.to32());
	176294	const elem_rc: Register.Class, const param_regs = switch (dst_arg) {
	176295	else => unreachable,
	176296	.elementwise_gpr => .{ .general_purpose, abi.getCAbiIntParamRegs(fn_info.cc) },
	176297	.elementwise_sse => .{ .sse, abi.getCAbiSseParamRegs(fn_info.cc, cg.target) },
	176298	};
	176299	const len = arg_ty.vectorLen(zcu);
	176300	const param_reg_len: u31 =
	176301	@intCast(@min(param_regs.len - regs_frame_addr.info.reg_index, len));
	176302
	176303	if (len - param_reg_len > 0) {
	176304	const index_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gp);
	176305	const index_lock = cg.register_manager.lockRegAssumeUnused(index_reg);
	176306	defer cg.register_manager.unlockReg(index_lock);
	176307	try cg.asmRegisterImmediate(.{ ._, .mov }, index_reg.to32(), .u(param_reg_len));
	176308
	176309	const loop: Mir.Inst.Index = @intCast(cg.mir_instructions.len);
	176310	const elem_ty = arg_ty.childType(zcu);
	176311	if (elem_ty.toIntern() == .bool_type) {
	176312	try cg.asmMemoryRegister(.{ ._, .bt }, src_mem, index_reg.to32());
	176313	try cg.asmSetccMemory(.c, .{
	176314	.base = .{ .frame = regs_frame_addr.frame_index },
	176315	.mod = .{ .rm = .{
	176316	.size = .byte,
	176317	.index = index_reg.to64(),
	176318	.scale = .@"8",
	176319	.disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_reg_len,
	176320	} },
	176321	});
	176322	} else {
	176323	const elem_reg =
	176324	try cg.register_manager.allocReg(null, regSetForRegClass(elem_rc));
	176325	const elem_lock = cg.register_manager.lockRegAssumeUnused(elem_reg);
	176326	defer cg.register_manager.unlockReg(elem_lock);
	176327	const elem_size = cg.memSize(elem_ty, .general_purpose);
	176328	const elem_alias = elem_reg.toSize(elem_size, cg.target);
	176329
	176330	const strat = try cg.moveStrategy(elem_ty, elem_rc, true);
	176331	assert(src_mem.mod.rm.index == .none and src_mem.mod.rm.scale == .@"1");
	176332	try strat.read(cg, elem_alias, .{
	176333	.base = src_mem.base,
	176334	.mod = .{ .rm = .{
	176335	.size = elem_size,
	176336	.index = index_reg.to64(),
	176337	.scale = .fromFactor(@intCast(@divExact(elem_size.bitSize(cg.target), 8))),
	176338	.disp = src_mem.mod.rm.disp,
	176339	} },
	176340	});
	176341	try strat.write(cg, .{
	176342	.base = .{ .frame = regs_frame_addr.frame_index },
	176343	.mod = .{ .rm = .{
	176344	.size = elem_size,
	176345	.index = index_reg.to64(),
	176346	.scale = .@"8",
	176347	.disp = @as(i32, regs_frame_addr.info.frame_off) - 8 * param_reg_len,
	176348	} },
	176349	}, elem_alias);
	176350	}
	176351	if (cg.hasFeature(.slow_incdec)) {
	176352	try cg.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), .u(1));
	176353	} else {
	176354	try cg.asmRegister(.{ ._c, .in }, index_reg.to32());
	176355	}
	176356	try cg.asmRegisterImmediate(.{ ._, .cmp }, index_reg.to32(), .u(len));
	176357	_ = try cg.asmJccReloc(.b, loop);
176092	176358	}
176093		try self.asmRegisterImmediate(
176094		.{ ._, .cmp },
176095		index_reg.to32(),
176096		.u(arg_ty.vectorLen(zcu)),
	176359
	176360	for (param_regs[regs_frame_addr.info.reg_index..][0..param_reg_len]) \|dst_reg\| {
	176361	try cg.register_manager.getReg(dst_reg, null);
	176362	try reg_locks.append(cg.register_manager.lockReg(dst_reg));
	176363	}
	176364	},
	176365	.xwordwise_sse, .ywordwise_sse, .zwordwise_sse => \|regs_frame_addr\| {
	176366	const elem_size: u31 = switch (dst_arg) {
	176367	else => unreachable,
	176368	.xwordwise_sse => 16,
	176369	.ywordwise_sse => 32,
	176370	.zwordwise_sse => 64,
	176371	};
	176372	const param_gpr_regs = abi.getCAbiIntParamRegs(fn_info.cc);
	176373	const arg_size: u31 = @intCast(arg_ty.abiSize(zcu));
	176374	const len = @divExact(arg_size, elem_size);
	176375	const param_gpr_len: u31 =
	176376	@intCast(@min(param_gpr_regs.len - regs_frame_addr.info.reg_index, len));
	176377
	176378	frame_index.* = try cg.allocFrameIndex(.initType(arg_ty, zcu));
	176379	try cg.genSetMem(.{ .frame = frame_index.* }, 0, arg_ty, src_arg, opts);
	176380
	176381	var frame_offset: i32 = regs_frame_addr.info.frame_off;
	176382	var arg_offset = elem_size * param_gpr_len;
	176383	while (arg_size - arg_offset != 0) : ({
	176384	frame_offset += 8;
	176385	arg_offset += elem_size;
	176386	}) try cg.genSetMem(
	176387	.{ .frame = regs_frame_addr.frame_index },
	176388	frame_offset,
	176389	.usize,
	176390	.{ .lea_frame = .{ .index = frame_index.*, .off = arg_offset } },
	176391	opts,
176097	176392	);
176098		_ = try self.asmJccReloc(.b, loop);
176099	176393
176100		const param_int_regs = abi.getCAbiIntParamRegs(fn_info.cc);
176101		for (param_int_regs[param_int_regs.len - regs_frame_addr.regs ..]) \|dst_reg\| {
176102		try self.register_manager.getReg(dst_reg, null);
176103		try reg_locks.append(self.register_manager.lockReg(dst_reg));
	176394	for (param_gpr_regs[regs_frame_addr.info.reg_index..][0..param_gpr_len]) \|dst_reg\| {
	176395	try cg.register_manager.getReg(dst_reg, null);
	176396	try reg_locks.append(cg.register_manager.lockReg(dst_reg));
176104	176397	}
176105	176398	},
176106	176399	else => unreachable,
176107	176400	};
176108	176401
176109	176402	if (call_info.err_ret_trace_reg != .none) {
176110		if (self.inst_tracking.getPtr(err_ret_trace_index)) \|err_ret_trace\| {
	176403	if (cg.inst_tracking.getPtr(err_ret_trace_index)) \|err_ret_trace\| {
176111	176404	if (switch (err_ret_trace.short) {
176112	176405	.register => \|reg\| call_info.err_ret_trace_reg != reg,
176113	176406	else => true,
176114	176407	}) {
176115		try self.register_manager.getReg(call_info.err_ret_trace_reg, err_ret_trace_index);
176116		try reg_locks.append(self.register_manager.lockReg(call_info.err_ret_trace_reg));
	176408	try cg.register_manager.getReg(call_info.err_ret_trace_reg, err_ret_trace_index);
	176409	try reg_locks.append(cg.register_manager.lockReg(call_info.err_ret_trace_reg));
176117	176410
176118		try self.genSetReg(call_info.err_ret_trace_reg, .usize, err_ret_trace.short, .{});
	176411	try cg.genSetReg(call_info.err_ret_trace_reg, .usize, err_ret_trace.short, opts);
176119	176412	err_ret_trace.trackMaterialize(err_ret_trace_index, .{
176120	176413	.long = err_ret_trace.long,
176121	176414	.short = .{ .register = call_info.err_ret_trace_reg },
...	...	@@ -176129,31 +176422,31 @@ fn genCall(self: *CodeGen, info: union(enum) {
176129	176422	.none, .unreach => {},
176130	176423	.indirect => \|reg_off\| {
176131	176424	const ret_ty: Type = .fromInterned(fn_info.return_type);
176132		const frame_index = try self.allocFrameIndex(.initSpill(ret_ty, zcu));
176133		try self.genSetReg(reg_off.reg, .usize, .{
	176425	const frame_index = try cg.allocFrameIndex(.initSpill(ret_ty, zcu));
	176426	try cg.genSetReg(reg_off.reg, .usize, .{
176134	176427	.lea_frame = .{ .index = frame_index, .off = -reg_off.off },
176135		}, .{});
	176428	}, opts);
176136	176429	call_info.return_value.short = .{ .load_frame = .{ .index = frame_index } };
176137		try reg_locks.append(self.register_manager.lockReg(reg_off.reg));
	176430	try reg_locks.append(cg.register_manager.lockReg(reg_off.reg));
176138	176431	},
176139	176432	else => unreachable,
176140	176433	}
176141	176434
176142	176435	for (call_info.args, arg_types, args, frame_indices, 0..) \|dst_arg, arg_ty, src_arg, frame_index, arg_i\|
176143	176436	switch (dst_arg) {
176144		.none, .load_frame => {},
	176437	.none, .load_frame, .indirect_load_frame => {},
176145	176438	.register => \|dst_reg\| switch (fn_info.cc) {
176146		else => try self.genSetReg(registerAlias(
	176439	else => try cg.genSetReg(registerAlias(
176147	176440	dst_reg,
176148	176441	@intCast(arg_ty.abiSize(zcu)),
176149	176442	), arg_ty, src_arg, opts),
176150	176443	.x86_64_sysv, .x86_64_win => {
176151		const promoted_ty = self.promoteInt(arg_ty);
176152		const promoted_abi_size: u32 = @intCast(promoted_ty.abiSize(zcu));
176153		const dst_alias = registerAlias(dst_reg, promoted_abi_size);
176154		try self.genSetReg(dst_alias, promoted_ty, src_arg, opts);
	176444	const promoted_ty = cg.promoteInt(arg_ty);
	176445	const promoted_unaligned_size: u32 = @intCast(cg.unalignedSize(promoted_ty));
	176446	const dst_alias = registerAlias(dst_reg, promoted_unaligned_size);
	176447	try cg.genSetReg(dst_alias, promoted_ty, src_arg, opts);
176155	176448	if (promoted_ty.toIntern() != arg_ty.toIntern())
176156		try self.truncateRegister(arg_ty, dst_alias);
	176449	try cg.truncateRegister(arg_ty, dst_alias);
176157	176450
176158	176451	if (fn_info.is_var_args and
176159	176452	fn_info.cc == .x86_64_win and
...	...	@@ -176161,47 +176454,90 @@ fn genCall(self: *CodeGen, info: union(enum) {
176161	176454	arg_i < abi.Win64.c_abi_int_param_regs.len)
176162	176455	{
176163	176456	const int_dst_reg = abi.Win64.c_abi_int_param_regs[arg_i];
176164		const int_dst_alias = registerAlias(int_dst_reg, promoted_abi_size);
176165		try self.genSetReg(int_dst_alias, promoted_ty, .{ .register = dst_alias }, opts);
	176457	const int_dst_alias = registerAlias(int_dst_reg, promoted_unaligned_size);
	176458	try cg.genSetReg(int_dst_alias, promoted_ty, .{ .register = dst_alias }, opts);
176166	176459	}
176167	176460	},
176168	176461	},
176169		.register_pair => try self.genCopy(arg_ty, dst_arg, src_arg, opts),
176170		.indirect => \|reg_off\| try self.genSetReg(reg_off.reg, .usize, .{
	176462	.register_pair => try cg.genCopy(arg_ty, dst_arg, src_arg, opts),
	176463	.indirect => \|reg_off\| try cg.genSetReg(reg_off.reg, .usize, .{
176171	176464	.lea_frame = .{ .index = frame_index, .off = -reg_off.off },
176172		}, .{}),
176173		.elementwise_args => \|regs_frame_addr\| {
176174		const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(self, .{ .size = .dword }) else .{
176175		.base = .{ .reg = try self.copyToTmpRegister(
	176465	}, opts),
	176466	.elementwise_gpr, .elementwise_sse => \|regs_frame_addr\| {
	176467	const src_mem: Memory = if (src_arg.isBase()) try src_arg.mem(cg, .{ .size = .dword }) else .{
	176468	.base = .{ .reg = try cg.copyToTmpRegister(
176176	176469	.usize,
176177	176470	switch (src_arg) {
176178	176471	else => src_arg,
176179		.air_ref => \|src_ref\| try self.resolveInst(src_ref),
	176472	.air_ref => \|src_ref\| try cg.resolveInst(src_ref),
176180	176473	}.address(),
176181	176474	) },
176182	176475	.mod = .{ .rm = .{ .size = .dword } },
176183	176476	};
176184	176477	const src_lock = switch (src_mem.base) {
176185		.reg => \|src_reg\| self.register_manager.lockReg(src_reg),
	176478	.reg => \|src_reg\| cg.register_manager.lockReg(src_reg),
176186	176479	else => null,
176187	176480	};
176188		defer if (src_lock) \|lock\| self.register_manager.unlockReg(lock);
	176481	defer if (src_lock) \|lock\| cg.register_manager.unlockReg(lock);
176189	176482
176190		const param_int_regs = abi.getCAbiIntParamRegs(fn_info.cc);
	176483	const elem_rc: Register.Class, const param_regs = switch (dst_arg) {
	176484	else => unreachable,
	176485	.elementwise_gpr => .{ .general_purpose, abi.getCAbiIntParamRegs(fn_info.cc) },
	176486	.elementwise_sse => .{ .sse, abi.getCAbiSseParamRegs(fn_info.cc, cg.target) },
	176487	};
	176488	const len = arg_ty.vectorLen(zcu);
	176489	const elem_ty = arg_ty.childType(zcu);
	176490	const elem_size = cg.memSize(elem_ty, .general_purpose);
	176491	const elem_abi_size = @divExact(elem_size.bitSize(cg.target), 8);
	176492	const param_reg_len: u31 =
	176493	@intCast(@min(param_regs.len - regs_frame_addr.info.reg_index, len));
	176494	const strat = if (elem_ty.toIntern() == .bool_type) strat: {
	176495	try cg.spillEflagsIfOccupied();
	176496	break :strat undefined;
	176497	} else try cg.moveStrategy(elem_ty, elem_rc, true);
176191	176498	for (
176192		param_int_regs[param_int_regs.len - regs_frame_addr.regs ..],
	176499	param_regs[regs_frame_addr.info.reg_index..][0..param_reg_len],
176193	176500	0..,
176194		) \|dst_reg, elem_index\| {
176195		try self.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32());
176196		try self.asmMemoryImmediate(.{ ._, .bt }, src_mem, .u(elem_index));
176197		try self.asmSetccRegister(.c, dst_reg.to8());
	176501	) \|dst_reg, elem_index\| if (elem_ty.toIntern() == .bool_type) {
	176502	try cg.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32());
	176503	try cg.asmMemoryImmediate(.{ ._, .bt }, src_mem, .u(elem_index));
	176504	try cg.asmSetccRegister(.c, dst_reg.to8());
	176505	} else try strat.read(cg, dst_reg.toSize(elem_size, cg.target), .{
	176506	.base = src_mem.base,
	176507	.mod = .{ .rm = .{
	176508	.size = elem_size,
	176509	.disp = src_mem.mod.rm.disp + @as(u31, @intCast(elem_abi_size * elem_index)),
	176510	} },
	176511	});
	176512	},
	176513	.xwordwise_sse, .ywordwise_sse, .zwordwise_sse => \|regs_frame_addr\| {
	176514	const elem_size: u31 = switch (dst_arg) {
	176515	else => unreachable,
	176516	.xwordwise_sse => 16,
	176517	.ywordwise_sse => 32,
	176518	.zwordwise_sse => 64,
	176519	};
	176520	const param_gpr_regs = abi.getCAbiIntParamRegs(fn_info.cc);
	176521	const len = @divExact(arg_ty.abiSize(zcu), elem_size);
	176522	const param_gpr_len: u31 =
	176523	@intCast(@min(param_gpr_regs.len - regs_frame_addr.info.reg_index, len));
	176524
	176525	var arg_offset: u31 = 0;
	176526	for (param_gpr_regs[regs_frame_addr.info.reg_index..][0..param_gpr_len]) \|dst_reg\| {
	176527	try cg.genSetReg(
	176528	dst_reg,
	176529	.usize,
	176530	.{ .lea_frame = .{ .index = frame_index, .off = arg_offset } },
	176531	opts,
	176532	);
	176533	arg_offset += elem_size;
176198	176534	}
176199	176535	},
176200	176536	else => unreachable,
176201	176537	};
176202	176538
176203	176539	if (fn_info.is_var_args and fn_info.cc == .x86_64_sysv)
176204		try self.asmRegisterImmediate(.{ ._, .mov }, .al, .u(call_info.fp_count));
	176540	try cg.asmRegisterImmediate(.{ ._, .mov }, .al, .u(call_info.fp_count));
176205	176541
176206	176542	// Due to incremental compilation, how function calls are generated depends
176207	176543	// on linking.
...	...	@@ -176216,16 +176552,16 @@ fn genCall(self: *CodeGen, info: union(enum) {
176216	176552	} else func_key,
176217	176553	}) {
176218	176554	else => unreachable,
176219		.func => \|func\| try self.asmImmediate(.{ ._, .call }, .{ .nav = .{ .index = func.owner_nav } }),
176220		.@"extern" => \|@"extern"\| try self.asmImmediate(.{ ._, .call }, .{ .nav = .{ .index = @"extern".owner_nav } }),
	176555	.func => \|func\| try cg.asmImmediate(.{ ._, .call }, .{ .nav = .{ .index = func.owner_nav } }),
	176556	.@"extern" => \|@"extern"\| try cg.asmImmediate(.{ ._, .call }, .{ .nav = .{ .index = @"extern".owner_nav } }),
176221	176557	}
176222	176558	} else {
176223		assert(self.typeOf(callee).zigTypeTag(zcu) == .pointer);
	176559	assert(cg.typeOf(callee).zigTypeTag(zcu) == .pointer);
176224	176560	const scratch_reg = abi.getCAbiLinkerScratchReg(fn_info.cc);
176225		try self.genSetReg(scratch_reg, .usize, .{ .air_ref = callee }, .{});
176226		try self.asmRegister(.{ ._, .call }, scratch_reg);
	176561	try cg.genSetReg(scratch_reg, .usize, .{ .air_ref = callee }, opts);
	176562	try cg.asmRegister(.{ ._, .call }, scratch_reg);
176227	176563	},
176228		.extern_func => \|extern_func\| try self.asmImmediate(.{ ._, .call }, .{ .extern_func = try self.addString(extern_func.sym) }),
	176564	.extern_func => \|extern_func\| try cg.asmImmediate(.{ ._, .call }, .{ .extern_func = try cg.addString(extern_func.sym) }),
176229	176565	}
176230	176566	return call_info.return_value.short;
176231	176567	}
...	...	@@ -176291,7 +176627,11 @@ fn airRetLoad(self: *CodeGen, inst: Air.Inst.Index) !void {
176291	176627	const ptr_ty = self.typeOf(un_op);
176292	176628	switch (self.ret_mcv.short) {
176293	176629	.none => {},
176294		.register, .register_pair => try self.load(self.ret_mcv.short, ptr_ty, ptr),
	176630	.register,
	176631	.register_pair,
	176632	.register_triple,
	176633	.register_quadruple,
	176634	=> try self.load(self.ret_mcv.short, ptr_ty, ptr),
176295	176635	.indirect => \|reg_off\| try self.genSetReg(reg_off.reg, ptr_ty, ptr, .{}),
176296	176636	else => unreachable,
176297	176637	}
...	...	@@ -176504,17 +176844,13 @@ fn isErrPtr(self: *CodeGen, maybe_inst: ?Air.Inst.Index, ptr_ty: Type, ptr_mcv:
176504	176844	defer if (ptr_lock) \|lock\| self.register_manager.unlockReg(lock);
176505	176845
176506	176846	const err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_ty.errorUnionPayload(zcu), zcu));
176507		try self.asmMemoryImmediate(
176508		.{ ._, .cmp },
176509		.{
176510		.base = .{ .reg = ptr_reg },
176511		.mod = .{ .rm = .{
176512		.size = self.memSize(.anyerror),
176513		.disp = err_off,
176514		} },
176515		},
176516		.u(0),
176517		);
	176847	try self.asmMemoryImmediate(.{ ._, .cmp }, .{
	176848	.base = .{ .reg = ptr_reg },
	176849	.mod = .{ .rm = .{
	176850	.size = self.memSize(.anyerror, .general_purpose),
	176851	.disp = err_off,
	176852	} },
	176853	}, .u(0));
176518	176854
176519	176855	if (maybe_inst) \|inst\| self.eflags_inst = inst;
176520	176856	return MCValue{ .eflags = .a };
...	...	@@ -178302,7 +178638,11 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C
178302	178638	.lea_uav,
178303	178639	.lea_lazy_sym,
178304	178640	.lea_extern_func,
178305		.elementwise_args,
	178641	.elementwise_gpr,
	178642	.elementwise_sse,
	178643	.xwordwise_sse,
	178644	.ywordwise_sse,
	178645	.zwordwise_sse,
178306	178646	.reserved_frame,
178307	178647	.air_ref,
178308	178648	=> unreachable, // unmodifiable destination
...	...	@@ -178313,7 +178653,11 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C
178313	178653	.dead,
178314	178654	.undef,
178315	178655	.register_overflow,
178316		.elementwise_args,
	178656	.elementwise_gpr,
	178657	.elementwise_sse,
	178658	.xwordwise_sse,
	178659	.ywordwise_sse,
	178660	.zwordwise_sse,
178317	178661	.reserved_frame,
178318	178662	=> unreachable,
178319	178663	.immediate,
...	...	@@ -178414,9 +178758,9 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C
178414	178758
178415	178759	for ([_]bool{ false, true }) \|emit_hazard\| {
178416	178760	var hazard_count: u3 = 0;
178417		var part_disp: i32 = 0;
	178761	var part_disp: u31 = 0;
178418	178762	for (dst_regs, try self.splitType(dst_regs.len, ty), 0..) \|dst_reg, dst_ty, part_i\| {
178419		defer part_disp += @intCast(dst_ty.abiSize(pt.zcu));
	178763	defer part_disp += @intCast(self.unalignedSize(dst_ty));
178420	178764	const is_hazard = if (src_mcv.getReg()) \|src_reg\|
178421	178765	dst_reg.id() == src_reg.id()
178422	178766	else if (src_info) \|info\|
...	...	@@ -178483,36 +178827,40 @@ fn genCopy(self: *CodeGen, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: C
178483	178827	}
178484	178828
178485	178829	fn genSetReg(
178486		self: *CodeGen,
	178830	cg: *CodeGen,
178487	178831	dst_reg: Register,
178488	178832	ty: Type,
178489	178833	src_mcv: MCValue,
178490	178834	opts: CopyOptions,
178491	178835	) InnerError!void {
178492		const pt = self.pt;
	178836	const pt = cg.pt;
178493	178837	const zcu = pt.zcu;
178494	178838	const abi_size: u32 = @intCast(ty.abiSize(zcu));
178495		const dst_alias = registerAlias(dst_reg, abi_size);
178496		if (ty.bitSize(zcu) > dst_alias.size().bitSize(self.target))
178497		return self.fail("genSetReg called with a value larger than dst_reg", .{});
	178839	const dst_alias = registerAlias(dst_reg, @intCast(cg.unalignedSize(ty)));
	178840	if (ty.bitSize(zcu) > dst_alias.size().bitSize(cg.target))
	178841	return cg.fail("genSetReg called with a value larger than dst_reg", .{});
178498	178842	switch (src_mcv) {
178499	178843	.none,
178500	178844	.unreach,
178501	178845	.dead,
178502	178846	.indirect_load_frame,
178503		.elementwise_args,
	178847	.elementwise_gpr,
	178848	.elementwise_sse,
	178849	.xwordwise_sse,
	178850	.ywordwise_sse,
	178851	.zwordwise_sse,
178504	178852	.reserved_frame,
178505	178853	=> unreachable,
178506	178854	.undef => if (opts.safety) switch (dst_reg.class()) {
178507	178855	.general_purpose, .gphi => switch (abi_size) {
178508		1 => try self.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to8(), .u(0xaa)),
178509		2 => try self.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to16(), .u(0xaaaa)),
178510		3...4 => try self.asmRegisterImmediate(
	178856	1 => try cg.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to8(), .u(0xaa)),
	178857	2 => try cg.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to16(), .u(0xaaaa)),
	178858	3...4 => try cg.asmRegisterImmediate(
178511	178859	.{ ._, .mov },
178512	178860	dst_reg.to32(),
178513	178861	.s(@as(i32, @bitCast(@as(u32, 0xaaaaaaaa)))),
178514	178862	),
178515		5...8 => try self.asmRegisterImmediate(
	178863	5...8 => try cg.asmRegisterImmediate(
178516	178864	.{ ._, .mov },
178517	178865	dst_reg.to64(),
178518	178866	.u(0xaaaaaaaaaaaaaaaa),
...	...	@@ -178521,36 +178869,36 @@ fn genSetReg(
178521	178869	},
178522	178870	.segment, .mmx, .sse => {
178523	178871	const full_ty = try pt.vectorType(.{
178524		.len = self.vectorSize(.float),
	178872	.len = cg.vectorSize(.float),
178525	178873	.child = .u8_type,
178526	178874	});
178527		try self.genSetReg(dst_reg, full_ty, try self.lowerValue(
	178875	try cg.genSetReg(dst_reg, full_ty, try cg.lowerValue(
178528	178876	try pt.aggregateSplatValue(full_ty, try pt.intValue(.u8, 0xaa)),
178529	178877	), opts);
178530	178878	},
178531		.x87 => try self.genSetReg(dst_reg, .f80, try self.lowerValue(
	178879	.x87 => try cg.genSetReg(dst_reg, .f80, try cg.lowerValue(
178532	178880	try pt.floatValue(.f80, @as(f80, @bitCast(@as(u80, 0xaaaaaaaaaaaaaaaaaaaa)))),
178533	178881	), opts),
178534	178882	.ip, .cr, .dr => unreachable,
178535	178883	},
178536		.eflags => \|cc\| try self.asmSetccRegister(cc, dst_reg.to8()),
	178884	.eflags => \|cc\| try cg.asmSetccRegister(cc, dst_reg.to8()),
178537	178885	.immediate => \|imm\| {
178538	178886	if (imm == 0) {
178539	178887	// 32-bit moves zero-extend to 64-bit, so xoring the 32-bit
178540	178888	// register is the fastest way to zero a register.
178541		try self.spillEflagsIfOccupied();
178542		try self.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32());
	178889	try cg.spillEflagsIfOccupied();
	178890	try cg.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32());
178543	178891	} else if (abi_size > 4 and std.math.cast(u32, imm) != null) {
178544	178892	// 32-bit moves zero-extend to 64-bit.
178545		try self.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to32(), .u(imm));
	178893	try cg.asmRegisterImmediate(.{ ._, .mov }, dst_reg.to32(), .u(imm));
178546	178894	} else if (abi_size <= 4 and @as(i64, @bitCast(imm)) < 0) {
178547		try self.asmRegisterImmediate(
	178895	try cg.asmRegisterImmediate(
178548	178896	.{ ._, .mov },
178549	178897	dst_alias,
178550	178898	.s(@intCast(@as(i64, @bitCast(imm)))),
178551	178899	);
178552	178900	} else {
178553		try self.asmRegisterImmediate(
	178901	try cg.asmRegisterImmediate(
178554	178902	.{ ._, .mov },
178555	178903	dst_alias,
178556	178904	.u(imm),
...	...	@@ -178559,44 +178907,44 @@ fn genSetReg(
178559	178907	},
178560	178908	.register => \|src_reg\| if (dst_reg.id() != src_reg.id()) switch (dst_reg.class()) {
178561	178909	.general_purpose => switch (src_reg.class()) {
178562		.general_purpose => try self.asmRegisterRegister(
	178910	.general_purpose => try cg.asmRegisterRegister(
178563	178911	.{ ._, .mov },
178564	178912	dst_alias,
178565		registerAlias(src_reg, abi_size),
	178913	registerAlias(src_reg, @intCast(cg.unalignedSize(ty))),
178566	178914	),
178567		.gphi => if (dst_reg.isClass(.gphi)) try self.asmRegisterRegister(
	178915	.gphi => if (dst_reg.isClass(.gphi)) try cg.asmRegisterRegister(
178568	178916	.{ ._, .mov },
178569	178917	dst_alias,
178570		registerAlias(src_reg, abi_size),
	178918	registerAlias(src_reg, @intCast(cg.unalignedSize(ty))),
178571	178919	) else {
178572		const src_lock = self.register_manager.lockReg(src_reg);
178573		defer if (src_lock) \|lock\| self.register_manager.unlockReg(lock);
178574		const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gphi);
	178920	const src_lock = cg.register_manager.lockReg(src_reg);
	178921	defer if (src_lock) \|lock\| cg.register_manager.unlockReg(lock);
	178922	const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gphi);
178575	178923
178576		try self.asmRegisterRegister(.{ ._, .mov }, tmp_reg.to8(), src_reg);
178577		try self.asmRegisterRegister(.{ ._, .mov }, dst_alias, tmp_reg.to8());
	178924	try cg.asmRegisterRegister(.{ ._, .mov }, tmp_reg.to8(), src_reg);
	178925	try cg.asmRegisterRegister(.{ ._, .mov }, dst_alias, tmp_reg.to8());
178578	178926	},
178579		.segment => try self.asmRegisterRegister(
	178927	.segment => try cg.asmRegisterRegister(
178580	178928	.{ ._, .mov },
178581	178929	dst_alias,
178582	178930	src_reg,
178583	178931	),
178584	178932	.x87, .mmx, .ip, .cr, .dr => unreachable,
178585		.sse => if (self.hasFeature(.sse2)) try self.asmRegisterRegister(
	178933	.sse => if (cg.hasFeature(.sse2)) try cg.asmRegisterRegister(
178586	178934	switch (abi_size) {
178587		1...4 => if (self.hasFeature(.avx)) .{ .v_d, .mov } else .{ ._d, .mov },
178588		5...8 => if (self.hasFeature(.avx)) .{ .v_q, .mov } else .{ ._q, .mov },
	178935	1...4 => if (cg.hasFeature(.avx)) .{ .v_d, .mov } else .{ ._d, .mov },
	178936	5...8 => if (cg.hasFeature(.avx)) .{ .v_q, .mov } else .{ ._q, .mov },
178589	178937	else => unreachable,
178590	178938	},
178591		registerAlias(dst_reg, @max(abi_size, 4)),
	178939	registerAlias(dst_reg, @intCast(@max(cg.unalignedSize(ty), 4))),
178592	178940	src_reg.to128(),
178593	178941	) else {
178594	178942	const frame_size = std.math.ceilPowerOfTwoAssert(u32, @max(abi_size, 4));
178595		const frame_index = try self.allocFrameIndex(.init(.{
	178943	const frame_index = try cg.allocFrameIndex(.init(.{
178596	178944	.size = frame_size,
178597	178945	.alignment = .fromNonzeroByteUnits(frame_size),
178598	178946	}));
178599		try self.asmMemoryRegister(switch (frame_size) {
	178947	try cg.asmMemoryRegister(switch (frame_size) {
178600	178948	4 => .{ ._ss, .mov },
178601	178949	8 => .{ ._ps, .movl },
178602	178950	16 => .{ ._ps, .mov },
...	...	@@ -178605,82 +178953,85 @@ fn genSetReg(
178605	178953	.base = .{ .frame = frame_index },
178606	178954	.mod = .{ .rm = .{ .size = .fromSize(frame_size) } },
178607	178955	}, src_reg.to128());
178608		try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
	178956	try cg.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
178609	178957	.base = .{ .frame = frame_index },
178610	178958	.mod = .{ .rm = .{ .size = .fromSize(abi_size) } },
178611	178959	});
178612	178960	},
178613	178961	},
178614	178962	.gphi => switch (src_reg.class()) {
178615		.general_purpose => if (src_reg.isClass(.gphi)) try self.asmRegisterRegister(
	178963	.general_purpose => if (src_reg.isClass(.gphi)) try cg.asmRegisterRegister(
178616	178964	.{ ._, .mov },
178617	178965	dst_alias,
178618		registerAlias(src_reg, abi_size),
	178966	registerAlias(src_reg, @intCast(cg.unalignedSize(ty))),
178619	178967	) else {
178620		const dst_lock = self.register_manager.lockReg(dst_reg);
178621		defer if (dst_lock) \|lock\| self.register_manager.unlockReg(lock);
178622		const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gphi);
	178968	const dst_lock = cg.register_manager.lockReg(dst_reg);
	178969	defer if (dst_lock) \|lock\| cg.register_manager.unlockReg(lock);
	178970	const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.gphi);
178623	178971
178624		try self.asmRegisterRegister(.{ ._, .mov }, tmp_reg.to8(), src_reg.to8());
178625		try self.asmRegisterRegister(.{ ._, .mov }, dst_reg, tmp_reg.to8());
	178972	try cg.asmRegisterRegister(.{ ._, .mov }, tmp_reg.to8(), src_reg.to8());
	178973	try cg.asmRegisterRegister(.{ ._, .mov }, dst_reg, tmp_reg.to8());
178626	178974	},
178627		.gphi => try self.asmRegisterRegister(
	178975	.gphi => try cg.asmRegisterRegister(
178628	178976	.{ ._, .mov },
178629	178977	dst_alias,
178630		registerAlias(src_reg, abi_size),
	178978	registerAlias(src_reg, @intCast(cg.unalignedSize(ty))),
178631	178979	),
178632	178980	.segment, .x87, .mmx, .ip, .cr, .dr, .sse => unreachable,
178633	178981	},
178634		.segment => try self.asmRegisterRegister(
	178982	.segment => try cg.asmRegisterRegister(
178635	178983	.{ ._, .mov },
178636	178984	dst_reg,
178637	178985	switch (src_reg.class()) {
178638		.general_purpose, .gphi, .segment => registerAlias(src_reg, abi_size),
	178986	.general_purpose,
	178987	.gphi,
	178988	.segment,
	178989	=> registerAlias(src_reg, @intCast(cg.unalignedSize(ty))),
178639	178990	.x87, .mmx, .ip, .cr, .dr => unreachable,
178640		.sse => try self.copyToTmpRegister(ty, src_mcv),
	178991	.sse => try cg.copyToTmpRegister(ty, src_mcv),
178641	178992	},
178642	178993	),
178643	178994	.x87 => switch (src_reg.class()) {
178644	178995	.general_purpose, .gphi, .segment, .mmx, .ip, .cr, .dr => unreachable,
178645	178996	.x87 => switch (src_reg) {
178646		.st0 => try self.asmRegister(.{ .f_, .st }, dst_reg),
	178997	.st0 => try cg.asmRegister(.{ .f_, .st }, dst_reg),
178647	178998	.st1, .st2, .st3, .st4, .st5, .st6 => switch (dst_reg) {
178648	178999	.st0 => {
178649		try self.asmRegister(.{ .f_p, .st }, .st0);
178650		try self.asmRegister(.{ .f_, .ld }, @enumFromInt(@intFromEnum(src_reg) - 1));
	179000	try cg.asmRegister(.{ .f_p, .st }, .st0);
	179001	try cg.asmRegister(.{ .f_, .ld }, @enumFromInt(@intFromEnum(src_reg) - 1));
178651	179002	},
178652		.st2, .st3, .st4, .st5, .st6 => if (self.register_manager.isKnownRegFree(.st7)) {
178653		try self.asmRegister(.{ .f_, .ld }, src_reg);
178654		try self.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1));
	179003	.st2, .st3, .st4, .st5, .st6 => if (cg.register_manager.isKnownRegFree(.st7)) {
	179004	try cg.asmRegister(.{ .f_, .ld }, src_reg);
	179005	try cg.asmRegister(.{ .f_p, .st }, @enumFromInt(@intFromEnum(dst_reg) + 1));
178655	179006	} else {
178656		try self.asmRegister(.{ .f_, .xch }, src_reg);
178657		try self.asmRegister(.{ .f_, .xch }, dst_reg);
178658		try self.asmRegister(.{ .f_, .xch }, src_reg);
	179007	try cg.asmRegister(.{ .f_, .xch }, src_reg);
	179008	try cg.asmRegister(.{ .f_, .xch }, dst_reg);
	179009	try cg.asmRegister(.{ .f_, .xch }, src_reg);
178659	179010	},
178660	179011	.st7 => {
178661		if (!self.register_manager.isKnownRegFree(.st7)) try self.asmRegister(.{ .f_, .free }, dst_reg);
178662		try self.asmRegister(.{ .f_, .ld }, src_reg);
178663		try self.asmOpOnly(.{ .f_cstp, .in });
	179012	if (!cg.register_manager.isKnownRegFree(.st7)) try cg.asmRegister(.{ .f_, .free }, dst_reg);
	179013	try cg.asmRegister(.{ .f_, .ld }, src_reg);
	179014	try cg.asmOpOnly(.{ .f_cstp, .in });
178664	179015	},
178665	179016	else => unreachable,
178666	179017	},
178667	179018	else => unreachable,
178668	179019	},
178669	179020	.sse => if (abi_size <= 16) {
178670		const frame_index = try self.allocFrameIndex(.init(.{
	179021	const frame_index = try cg.allocFrameIndex(.init(.{
178671	179022	.size = 16,
178672	179023	.alignment = .@"16",
178673	179024	}));
178674		try self.asmMemoryRegister(if (self.hasFeature(.avx))
	179025	try cg.asmMemoryRegister(if (cg.hasFeature(.avx))
178675	179026	.{ .v_dqa, .mov }
178676		else if (self.hasFeature(.sse2))
	179027	else if (cg.hasFeature(.sse2))
178677	179028	.{ ._dqa, .mov }
178678	179029	else
178679	179030	.{ ._ps, .mova }, .{
178680	179031	.base = .{ .frame = frame_index },
178681	179032	.mod = .{ .rm = .{ .size = .xword } },
178682	179033	}, src_reg.to128());
178683		try MoveStrategy.read(.load_store_x87, self, dst_reg, .{
	179034	try MoveStrategy.read(.load_store_x87, cg, dst_reg, .{
178684	179035	.base = .{ .frame = frame_index },
178685	179036	.mod = .{ .rm = .{ .size = .tbyte } },
178686	179037	});
...	...	@@ -178688,29 +179039,29 @@ fn genSetReg(
178688	179039	},
178689	179040	.mmx => unreachable,
178690	179041	.sse => switch (src_reg.class()) {
178691		.general_purpose, .gphi => if (self.hasFeature(.sse2)) try self.asmRegisterRegister(
	179042	.general_purpose, .gphi => if (cg.hasFeature(.sse2)) try cg.asmRegisterRegister(
178692	179043	switch (abi_size) {
178693		1...4 => if (self.hasFeature(.avx)) .{ .v_d, .mov } else .{ ._d, .mov },
178694		5...8 => if (self.hasFeature(.avx)) .{ .v_q, .mov } else .{ ._q, .mov },
	179044	1...4 => if (cg.hasFeature(.avx)) .{ .v_d, .mov } else .{ ._d, .mov },
	179045	5...8 => if (cg.hasFeature(.avx)) .{ .v_q, .mov } else .{ ._q, .mov },
178695	179046	else => unreachable,
178696	179047	},
178697	179048	dst_reg.to128(),
178698		registerAlias(src_reg, @max(abi_size, 4)),
	179049	registerAlias(src_reg, @intCast(@max(cg.unalignedSize(ty), 4))),
178699	179050	) else {
178700	179051	const frame_size = std.math.ceilPowerOfTwoAssert(u32, @max(abi_size, 4));
178701		const frame_index = try self.allocFrameIndex(.init(.{
	179052	const frame_index = try cg.allocFrameIndex(.init(.{
178702	179053	.size = frame_size,
178703	179054	.alignment = .fromNonzeroByteUnits(frame_size),
178704	179055	}));
178705		try self.asmMemoryRegister(.{ ._, .mov }, .{
	179056	try cg.asmMemoryRegister(.{ ._, .mov }, .{
178706	179057	.base = .{ .frame = frame_index },
178707	179058	.mod = .{ .rm = .{ .size = .fromSize(abi_size) } },
178708		}, registerAlias(src_reg, abi_size));
	179059	}, registerAlias(src_reg, @intCast(cg.unalignedSize(ty))));
178709	179060	switch (frame_size) {
178710	179061	else => {},
178711		8 => try self.asmRegisterRegister(.{ ._ps, .xor }, dst_reg.to128(), dst_reg.to128()),
	179062	8 => try cg.asmRegisterRegister(.{ ._ps, .xor }, dst_reg.to128(), dst_reg.to128()),
178712	179063	}
178713		try self.asmRegisterMemory(switch (frame_size) {
	179064	try cg.asmRegisterMemory(switch (frame_size) {
178714	179065	4 => .{ ._ss, .mov },
178715	179066	8 => .{ ._ps, .movl },
178716	179067	16 => .{ ._ps, .mova },
...	...	@@ -178720,24 +179071,24 @@ fn genSetReg(
178720	179071	.mod = .{ .rm = .{ .size = .fromSize(frame_size) } },
178721	179072	});
178722	179073	},
178723		.segment => try self.genSetReg(
	179074	.segment => try cg.genSetReg(
178724	179075	dst_reg,
178725	179076	ty,
178726		.{ .register = try self.copyToTmpRegister(ty, src_mcv) },
	179077	.{ .register = try cg.copyToTmpRegister(ty, src_mcv) },
178727	179078	opts,
178728	179079	),
178729	179080	.x87 => if (abi_size <= 16) {
178730		const frame_index = try self.allocFrameIndex(.init(.{
	179081	const frame_index = try cg.allocFrameIndex(.init(.{
178731	179082	.size = 16,
178732	179083	.alignment = .@"16",
178733	179084	}));
178734		try MoveStrategy.write(.load_store_x87, self, .{
	179085	try MoveStrategy.write(.load_store_x87, cg, .{
178735	179086	.base = .{ .frame = frame_index },
178736	179087	.mod = .{ .rm = .{ .size = .tbyte } },
178737	179088	}, src_reg);
178738		try self.asmRegisterMemory(if (self.hasFeature(.avx))
	179089	try cg.asmRegisterMemory(if (cg.hasFeature(.avx))
178739	179090	.{ .v_dqa, .mov }
178740		else if (self.hasFeature(.sse2))
	179091	else if (cg.hasFeature(.sse2))
178741	179092	.{ ._dqa, .mov }
178742	179093	else
178743	179094	.{ ._ps, .mova }, dst_reg.to128(), .{
...	...	@@ -178746,46 +179097,46 @@ fn genSetReg(
178746	179097	});
178747	179098	} else unreachable,
178748	179099	.mmx, .ip, .cr, .dr => unreachable,
178749		.sse => try self.asmRegisterRegister(
	179100	.sse => try cg.asmRegisterRegister(
178750	179101	@as(?Mir.Inst.FixedTag, switch (ty.scalarType(zcu).zigTypeTag(zcu)) {
178751	179102	else => switch (abi_size) {
178752		1...16 => if (self.hasFeature(.avx))
	179103	1...16 => if (cg.hasFeature(.avx))
178753	179104	.{ .v_dqa, .mov }
178754		else if (self.hasFeature(.sse2))
	179105	else if (cg.hasFeature(.sse2))
178755	179106	.{ ._dqa, .mov }
178756	179107	else
178757	179108	.{ ._ps, .mova },
178758		17...32 => if (self.hasFeature(.avx)) .{ .v_dqa, .mov } else null,
	179109	17...32 => if (cg.hasFeature(.avx)) .{ .v_dqa, .mov } else null,
178759	179110	else => null,
178760	179111	},
178761		.float => switch (ty.scalarType(zcu).floatBits(self.target)) {
	179112	.float => switch (ty.scalarType(zcu).floatBits(cg.target)) {
178762	179113	16, 128 => switch (abi_size) {
178763		2...16 => if (self.hasFeature(.avx))
	179114	2...16 => if (cg.hasFeature(.avx))
178764	179115	.{ .v_dqa, .mov }
178765		else if (self.hasFeature(.sse2))
	179116	else if (cg.hasFeature(.sse2))
178766	179117	.{ ._dqa, .mov }
178767	179118	else
178768	179119	.{ ._ps, .mova },
178769		17...32 => if (self.hasFeature(.avx)) .{ .v_dqa, .mov } else null,
	179120	17...32 => if (cg.hasFeature(.avx)) .{ .v_dqa, .mov } else null,
178770	179121	else => null,
178771	179122	},
178772		32 => if (self.hasFeature(.avx)) .{ .v_ps, .mova } else .{ ._ps, .mova },
178773		64 => if (self.hasFeature(.avx))
	179123	32 => if (cg.hasFeature(.avx)) .{ .v_ps, .mova } else .{ ._ps, .mova },
	179124	64 => if (cg.hasFeature(.avx))
178774	179125	.{ .v_pd, .mova }
178775		else if (self.hasFeature(.sse2))
	179126	else if (cg.hasFeature(.sse2))
178776	179127	.{ ._pd, .mova }
178777	179128	else
178778	179129	.{ ._ps, .mova },
178779	179130	80 => null,
178780	179131	else => unreachable,
178781	179132	},
178782		}) orelse return self.fail("TODO implement genSetReg for {f}", .{ty.fmt(pt)}),
	179133	}) orelse return cg.fail("TODO implement genSetReg for {f}", .{ty.fmt(pt)}),
178783	179134	dst_alias,
178784		registerAlias(src_reg, abi_size),
	179135	registerAlias(src_reg, @intCast(cg.unalignedSize(ty))),
178785	179136	),
178786	179137	},
178787	179138	.ip, .cr, .dr => unreachable,
178788		} else if ((dst_reg.class() == .gphi) != (src_reg.class() == .gphi)) try self.asmRegisterRegister(
	179139	} else if ((dst_reg.class() == .gphi) != (src_reg.class() == .gphi)) try cg.asmRegisterRegister(
178789	179140	.{ ._, .mov },
178790	179141	dst_reg.to8(),
178791	179142	src_reg.to8(),
...	...	@@ -178795,41 +179146,41 @@ fn genSetReg(
178795	179146	.register_quadruple,
178796	179147	=> \|src_regs\| switch (dst_reg.class()) {
178797	179148	.general_purpose => switch (src_regs[0].class()) {
178798		.general_purpose => try self.genSetReg(dst_reg, ty, .{ .register = src_regs[0] }, opts),
	179149	.general_purpose => try cg.genSetReg(dst_reg, ty, .{ .register = src_regs[0] }, opts),
178799	179150	else => unreachable,
178800	179151	},
178801	179152	.sse => switch (src_regs[0].class()) {
178802	179153	.general_purpose => if (abi_size <= 16) {
178803		if (self.hasFeature(.avx)) {
178804		try self.asmRegisterRegister(.{ .v_q, .mov }, dst_reg.to128(), src_regs[0].to64());
178805		try self.asmRegisterRegisterRegisterImmediate(
	179154	if (cg.hasFeature(.avx)) {
	179155	try cg.asmRegisterRegister(.{ .v_q, .mov }, dst_reg.to128(), src_regs[0].to64());
	179156	try cg.asmRegisterRegisterRegisterImmediate(
178806	179157	.{ .vp_q, .insr },
178807	179158	dst_reg.to128(),
178808	179159	dst_reg.to128(),
178809	179160	src_regs[1].to64(),
178810	179161	.u(1),
178811	179162	);
178812		} else if (self.hasFeature(.sse4_1)) {
178813		try self.asmRegisterRegister(.{ ._q, .mov }, dst_reg.to128(), src_regs[0].to64());
178814		try self.asmRegisterRegisterImmediate(.{ .p_q, .insr }, dst_reg.to128(), src_regs[1].to64(), .u(1));
178815		} else if (self.hasFeature(.sse2)) {
178816		const tmp_reg = try self.register_manager.allocReg(null, abi.RegisterClass.sse);
178817		const tmp_lock = self.register_manager.lockRegAssumeUnused(tmp_reg);
178818		defer self.register_manager.unlockReg(tmp_lock);
178819
178820		try self.asmRegisterRegister(.{ ._q, .mov }, dst_reg.to128(), src_regs[0].to64());
178821		try self.asmRegisterRegister(.{ ._q, .mov }, tmp_reg.to128(), src_regs[1].to64());
178822		try self.asmRegisterRegister(.{ ._ps, .movlh }, dst_reg.to128(), tmp_reg.to128());
	179163	} else if (cg.hasFeature(.sse4_1)) {
	179164	try cg.asmRegisterRegister(.{ ._q, .mov }, dst_reg.to128(), src_regs[0].to64());
	179165	try cg.asmRegisterRegisterImmediate(.{ .p_q, .insr }, dst_reg.to128(), src_regs[1].to64(), .u(1));
	179166	} else if (cg.hasFeature(.sse2)) {
	179167	const tmp_reg = try cg.register_manager.allocReg(null, abi.RegisterClass.sse);
	179168	const tmp_lock = cg.register_manager.lockRegAssumeUnused(tmp_reg);
	179169	defer cg.register_manager.unlockReg(tmp_lock);
	179170
	179171	try cg.asmRegisterRegister(.{ ._q, .mov }, dst_reg.to128(), src_regs[0].to64());
	179172	try cg.asmRegisterRegister(.{ ._q, .mov }, tmp_reg.to128(), src_regs[1].to64());
	179173	try cg.asmRegisterRegister(.{ ._ps, .movlh }, dst_reg.to128(), tmp_reg.to128());
178823	179174	} else {
178824		const frame_index = try self.allocFrameIndex(.init(.{
	179175	const frame_index = try cg.allocFrameIndex(.init(.{
178825	179176	.size = 16,
178826	179177	.alignment = .@"16",
178827	179178	}));
178828		for (src_regs, 0..) \|src_reg, src_index\| try self.asmMemoryRegister(.{ ._, .mov }, .{
	179179	for (src_regs, 0..) \|src_reg, src_index\| try cg.asmMemoryRegister(.{ ._, .mov }, .{
178829	179180	.base = .{ .frame = frame_index },
178830	179181	.mod = .{ .rm = .{ .size = .qword, .disp = @intCast(8 * src_index) } },
178831	179182	}, src_reg.to64());
178832		try self.asmRegisterMemory(.{ ._ps, .mova }, dst_reg.to128(), .{
	179183	try cg.asmRegisterMemory(.{ ._ps, .mova }, dst_reg.to128(), .{
178833	179184	.base = .{ .frame = frame_index },
178834	179185	.mod = .{ .rm = .{ .size = .xword } },
178835	179186	});
...	...	@@ -178843,38 +179194,41 @@ fn genSetReg(
178843	179194	.indirect,
178844	179195	.load_frame,
178845	179196	.lea_frame,
178846		=> try @as(MoveStrategy, switch (src_mcv) {
178847		.register_offset => \|reg_off\| switch (reg_off.off) {
178848		0 => return self.genSetReg(dst_reg, ty, .{ .register = reg_off.reg }, opts),
178849		else => .{ .load_store = .{ ._, .lea } },
178850		},
178851		.indirect => try self.moveStrategy(ty, dst_reg.class(), false),
178852		.load_frame => \|frame_addr\| try self.moveStrategy(
178853		ty,
178854		dst_reg.class(),
178855		self.getFrameAddrAlignment(frame_addr).compare(.gte, .fromLog2Units(
178856		std.math.log2_int_ceil(u64, @divExact(dst_reg.size().bitSize(self.target), 8)),
178857		)),
178858		),
178859		.lea_frame => .{ .load_store = .{ ._, .lea } },
178860		else => unreachable,
178861		}).read(self, dst_alias, switch (src_mcv) {
178862		.register_offset, .indirect => \|reg_off\| .{
178863		.base = .{ .reg = reg_off.reg.to64() },
178864		.mod = .{ .rm = .{
178865		.size = self.memSize(ty),
178866		.disp = reg_off.off,
178867		} },
178868		},
178869		.load_frame, .lea_frame => \|frame_addr\| .{
178870		.base = .{ .frame = frame_addr.index },
178871		.mod = .{ .rm = .{
178872		.size = self.memSize(ty),
178873		.disp = frame_addr.off,
178874		} },
178875		},
178876		else => unreachable,
178877		}),
	179197	=> {
	179198	const dst_rc = dst_reg.class();
	179199	try @as(MoveStrategy, switch (src_mcv) {
	179200	.register_offset => \|reg_off\| switch (reg_off.off) {
	179201	0 => return cg.genSetReg(dst_reg, ty, .{ .register = reg_off.reg }, opts),
	179202	else => .{ .load_store = .{ ._, .lea } },
	179203	},
	179204	.indirect => try cg.moveStrategy(ty, dst_rc, false),
	179205	.load_frame => \|frame_addr\| try cg.moveStrategy(
	179206	ty,
	179207	dst_rc,
	179208	cg.getFrameAddrAlignment(frame_addr).compare(.gte, .fromLog2Units(
	179209	std.math.log2_int_ceil(u64, @divExact(dst_reg.size().bitSize(cg.target), 8)),
	179210	)),
	179211	),
	179212	.lea_frame => .{ .load_store = .{ ._, .lea } },
	179213	else => unreachable,
	179214	}).read(cg, dst_alias, switch (src_mcv) {
	179215	.register_offset, .indirect => \|reg_off\| .{
	179216	.base = .{ .reg = reg_off.reg.to64() },
	179217	.mod = .{ .rm = .{
	179218	.size = cg.memSize(ty, dst_rc),
	179219	.disp = reg_off.off,
	179220	} },
	179221	},
	179222	.load_frame, .lea_frame => \|frame_addr\| .{
	179223	.base = .{ .frame = frame_addr.index },
	179224	.mod = .{ .rm = .{
	179225	.size = cg.memSize(ty, dst_rc),
	179226	.disp = frame_addr.off,
	179227	} },
	179228	},
	179229	else => unreachable,
	179230	});
	179231	},
178878	179232	.register_overflow => \|src_reg_ov\| {
178879	179233	const ip = &zcu.intern_pool;
178880	179234	const first_ty: Type = .fromInterned(first_ty: switch (ip.indexToKey(ty.toIntern())) {
...	...	@@ -178891,116 +179245,117 @@ fn genSetReg(
178891	179245	});
178892	179246	const first_size: u31 = @intCast(first_ty.abiSize(zcu));
178893	179247	const frame_size = std.math.ceilPowerOfTwoAssert(u32, abi_size);
178894		const frame_index = try self.allocFrameIndex(.init(.{
	179248	const frame_index = try cg.allocFrameIndex(.init(.{
178895	179249	.size = frame_size,
178896	179250	.alignment = .fromNonzeroByteUnits(frame_size),
178897	179251	}));
178898		try self.asmMemoryRegister(.{ ._, .mov }, .{
	179252	try cg.asmMemoryRegister(.{ ._, .mov }, .{
178899	179253	.base = .{ .frame = frame_index },
178900	179254	.mod = .{ .rm = .{ .size = .fromSize(first_size) } },
178901	179255	}, registerAlias(src_reg_ov.reg, first_size));
178902		try self.asmSetccMemory(src_reg_ov.eflags, .{
	179256	try cg.asmSetccMemory(src_reg_ov.eflags, .{
178903	179257	.base = .{ .frame = frame_index },
178904	179258	.mod = .{ .rm = .{ .size = .byte, .disp = first_size } },
178905	179259	});
178906		try self.asmRegisterMemory(.{ ._, .mov }, registerAlias(dst_reg, abi_size), .{
	179260	try cg.asmRegisterMemory(.{ ._, .mov }, registerAlias(dst_reg, abi_size), .{
178907	179261	.base = .{ .frame = frame_index },
178908	179262	.mod = .{ .rm = .{ .size = .fromSize(frame_size) } },
178909	179263	});
178910	179264	},
178911	179265	.register_mask => \|src_reg_mask\| {
178912	179266	assert(src_reg_mask.reg.isClass(.sse));
178913		const has_avx = self.hasFeature(.avx);
	179267	const has_avx = cg.hasFeature(.avx);
178914	179268	const bits_reg = switch (dst_reg.class()) {
178915	179269	.general_purpose => dst_reg,
178916		else => try self.register_manager.allocReg(null, abi.RegisterClass.gp),
	179270	else => try cg.register_manager.allocReg(null, abi.RegisterClass.gp),
178917	179271	};
178918		const bits_lock = self.register_manager.lockReg(bits_reg);
178919		defer if (bits_lock) \|lock\| self.register_manager.unlockReg(lock);
	179272	const bits_lock = cg.register_manager.lockReg(bits_reg);
	179273	defer if (bits_lock) \|lock\| cg.register_manager.unlockReg(lock);
178920	179274
178921	179275	const pack_reg = switch (src_reg_mask.info.scalar) {
178922	179276	else => src_reg_mask.reg,
178923		.word => try self.register_manager.allocReg(null, abi.RegisterClass.sse),
	179277	.word => try cg.register_manager.allocReg(null, abi.RegisterClass.sse),
178924	179278	};
178925		const pack_lock = self.register_manager.lockReg(pack_reg);
178926		defer if (pack_lock) \|lock\| self.register_manager.unlockReg(lock);
	179279	const pack_lock = cg.register_manager.lockReg(pack_reg);
	179280	defer if (pack_lock) \|lock\| cg.register_manager.unlockReg(lock);
178927	179281
178928		var mask_size: u32 = @intCast(ty.vectorLen(zcu) * @divExact(src_reg_mask.info.scalar.bitSize(self.target), 8));
	179282	var mask_size: u32 = @intCast(ty.vectorLen(zcu) * @divExact(src_reg_mask.info.scalar.bitSize(cg.target), 8));
178929	179283	switch (src_reg_mask.info.scalar) {
178930	179284	else => {},
178931	179285	.word => {
178932	179286	const src_alias = registerAlias(src_reg_mask.reg, mask_size);
178933	179287	const pack_alias = registerAlias(pack_reg, mask_size);
178934	179288	if (has_avx) {
178935		try self.asmRegisterRegisterRegister(.{ .vp_b, .ackssw }, pack_alias, src_alias, src_alias);
	179289	try cg.asmRegisterRegisterRegister(.{ .vp_b, .ackssw }, pack_alias, src_alias, src_alias);
178936	179290	} else {
178937		try self.asmRegisterRegister(.{ ._dqa, .mov }, pack_alias, src_alias);
178938		try self.asmRegisterRegister(.{ .p_b, .ackssw }, pack_alias, pack_alias);
	179291	try cg.asmRegisterRegister(.{ ._dqa, .mov }, pack_alias, src_alias);
	179292	try cg.asmRegisterRegister(.{ .p_b, .ackssw }, pack_alias, pack_alias);
178939	179293	}
178940	179294	mask_size = std.math.divCeil(u32, mask_size, 2) catch unreachable;
178941	179295	},
178942	179296	}
178943		try self.asmRegisterRegister(.{ switch (src_reg_mask.info.scalar) {
	179297	try cg.asmRegisterRegister(.{ switch (src_reg_mask.info.scalar) {
178944	179298	.byte, .word => if (has_avx) .vp_b else .p_b,
178945	179299	.dword => if (has_avx) .v_ps else ._ps,
178946	179300	.qword => if (has_avx) .v_pd else ._pd,
178947	179301	else => unreachable,
178948	179302	}, .movmsk }, bits_reg.to32(), registerAlias(pack_reg, mask_size));
178949		if (src_reg_mask.info.inverted) try self.asmRegister(.{ ._, .not }, registerAlias(bits_reg, abi_size));
178950		try self.genSetReg(dst_reg, ty, .{ .register = bits_reg }, .{});
	179303	if (src_reg_mask.info.inverted) try cg.asmRegister(.{ ._, .not }, registerAlias(bits_reg, abi_size));
	179304	try cg.genSetReg(dst_reg, ty, .{ .register = bits_reg }, .{});
178951	179305	},
178952	179306	.memory, .load_nav, .load_uav, .load_lazy_sym, .load_extern_func => {
	179307	const dst_rc = dst_reg.class();
178953	179308	switch (src_mcv) {
178954	179309	.memory => \|addr\| if (std.math.cast(i32, @as(i64, @bitCast(addr)))) \|small_addr\|
178955		return (try self.moveStrategy(
	179310	return (try cg.moveStrategy(
178956	179311	ty,
178957		dst_reg.class(),
	179312	dst_rc,
178958	179313	ty.abiAlignment(zcu).check(@as(u32, @bitCast(small_addr))),
178959		)).read(self, dst_alias, .{
	179314	)).read(cg, dst_alias, .{
178960	179315	.base = .{ .reg = .ds },
178961	179316	.mod = .{ .rm = .{
178962		.size = self.memSize(ty),
	179317	.size = cg.memSize(ty, dst_rc),
178963	179318	.disp = small_addr,
178964	179319	} },
178965	179320	}),
178966		.load_nav => \|nav\| switch (dst_reg.class()) {
	179321	.load_nav => \|nav\| switch (dst_rc) {
178967	179322	.general_purpose, .gphi => {
178968		try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
	179323	try cg.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
178969	179324	.base = .{ .nav = nav },
178970		.mod = .{ .rm = .{ .size = self.memSize(ty) } },
	179325	.mod = .{ .rm = .{ .size = cg.memSize(ty, dst_rc) } },
178971	179326	});
178972	179327	return;
178973	179328	},
178974	179329	.segment, .mmx, .ip, .cr, .dr => unreachable,
178975	179330	.x87, .sse => {},
178976	179331	},
178977		.load_uav => \|uav\| switch (dst_reg.class()) {
	179332	.load_uav => \|uav\| switch (dst_rc) {
178978	179333	.general_purpose, .gphi => {
178979		try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
	179334	try cg.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
178980	179335	.base = .{ .uav = uav },
178981		.mod = .{ .rm = .{ .size = self.memSize(ty) } },
	179336	.mod = .{ .rm = .{ .size = cg.memSize(ty, dst_rc) } },
178982	179337	});
178983	179338	return;
178984	179339	},
178985	179340	.segment, .mmx, .ip, .cr, .dr => unreachable,
178986	179341	.x87, .sse => {},
178987	179342	},
178988		.load_lazy_sym => \|lazy_sym\| switch (dst_reg.class()) {
	179343	.load_lazy_sym => \|lazy_sym\| switch (dst_rc) {
178989	179344	.general_purpose, .gphi => {
178990		try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
	179345	try cg.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
178991	179346	.base = .{ .lazy_sym = lazy_sym },
178992		.mod = .{ .rm = .{ .size = self.memSize(ty) } },
	179347	.mod = .{ .rm = .{ .size = cg.memSize(ty, dst_rc) } },
178993	179348	});
178994	179349	return;
178995	179350	},
178996	179351	.segment, .mmx, .ip, .cr, .dr => unreachable,
178997	179352	.x87, .sse => {},
178998	179353	},
178999		.load_extern_func => \|extern_func\| switch (dst_reg.class()) {
	179354	.load_extern_func => \|extern_func\| switch (dst_rc) {
179000	179355	.general_purpose, .gphi => {
179001		try self.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
	179356	try cg.asmRegisterMemory(.{ ._, .mov }, dst_alias, .{
179002	179357	.base = .{ .extern_func = extern_func },
179003		.mod = .{ .rm = .{ .size = self.memSize(ty) } },
	179358	.mod = .{ .rm = .{ .size = cg.memSize(ty, dst_rc) } },
179004	179359	});
179005	179360	return;
179006	179361	},
...	...	@@ -179010,40 +179365,40 @@ fn genSetReg(
179010	179365	else => unreachable,
179011	179366	}
179012	179367
179013		const addr_reg = try self.copyToTmpRegister(.usize, src_mcv.address());
179014		const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
179015		defer self.register_manager.unlockReg(addr_lock);
	179368	const addr_reg = try cg.copyToTmpRegister(.usize, src_mcv.address());
	179369	const addr_lock = cg.register_manager.lockRegAssumeUnused(addr_reg);
	179370	defer cg.register_manager.unlockReg(addr_lock);
179016	179371
179017		try (try self.moveStrategy(ty, dst_reg.class(), false)).read(self, dst_alias, .{
	179372	try (try cg.moveStrategy(ty, dst_rc, false)).read(cg, dst_alias, .{
179018	179373	.base = .{ .reg = addr_reg.to64() },
179019		.mod = .{ .rm = .{ .size = self.memSize(ty) } },
	179374	.mod = .{ .rm = .{ .size = cg.memSize(ty, dst_rc) } },
179020	179375	});
179021	179376	},
179022		.lea_nav => \|nav\| try self.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{
	179377	.lea_nav => \|nav\| try cg.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{
179023	179378	.base = .{ .nav = nav },
179024	179379	}),
179025		.lea_uav => \|uav\| try self.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{
	179380	.lea_uav => \|uav\| try cg.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{
179026	179381	.base = .{ .uav = uav },
179027	179382	}),
179028		.lea_lazy_sym => \|lazy_sym\| try self.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{
	179383	.lea_lazy_sym => \|lazy_sym\| try cg.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{
179029	179384	.base = .{ .lazy_sym = lazy_sym },
179030	179385	}),
179031		.lea_extern_func => \|lazy_sym\| try self.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{
	179386	.lea_extern_func => \|lazy_sym\| try cg.asmRegisterMemory(.{ ._, .lea }, dst_reg.to64(), .{
179032	179387	.base = .{ .extern_func = lazy_sym },
179033	179388	}),
179034		.air_ref => \|src_ref\| try self.genSetReg(dst_reg, ty, try self.resolveInst(src_ref), opts),
	179389	.air_ref => \|src_ref\| try cg.genSetReg(dst_reg, ty, try cg.resolveInst(src_ref), opts),
179035	179390	}
179036	179391	}
179037	179392
179038	179393	fn genSetMem(
179039		self: *CodeGen,
	179394	cg: *CodeGen,
179040	179395	base: Memory.Base,
179041	179396	disp: i32,
179042	179397	ty: Type,
179043	179398	src_mcv: MCValue,
179044	179399	opts: CopyOptions,
179045	179400	) InnerError!void {
179046		const pt = self.pt;
	179401	const pt = cg.pt;
179047	179402	const zcu = pt.zcu;
179048	179403	const abi_size: u32 = @intCast(ty.abiSize(zcu));
179049	179404	const dst_ptr_mcv: MCValue = switch (base) {
...	...	@@ -179053,11 +179408,11 @@ fn genSetMem(
179053	179408	.table, .rip_inst, .lazy_sym => unreachable,
179054	179409	.nav => \|nav\| {
179055	179410	// hack around linker relocation bugs
179056		const addr_reg = try self.copyToTmpRegister(.usize, .{ .lea_nav = nav });
179057		const addr_lock = self.register_manager.lockRegAssumeUnused(addr_reg);
179058		defer self.register_manager.unlockReg(addr_lock);
	179411	const addr_reg = try cg.copyToTmpRegister(.usize, .{ .lea_nav = nav });
	179412	const addr_lock = cg.register_manager.lockRegAssumeUnused(addr_reg);
	179413	defer cg.register_manager.unlockReg(addr_lock);
179059	179414
179060		return self.genSetMem(.{ .reg = addr_reg }, disp, ty, src_mcv, opts);
	179415	return cg.genSetMem(.{ .reg = addr_reg }, disp, ty, src_mcv, opts);
179061	179416	},
179062	179417	.uav => \|uav\| .{ .lea_uav = uav },
179063	179418	.extern_func => \|extern_func\| .{ .lea_extern_func = extern_func },
...	...	@@ -179067,10 +179422,14 @@ fn genSetMem(
179067	179422	.unreach,
179068	179423	.dead,
179069	179424	.indirect_load_frame,
179070		.elementwise_args,
	179425	.elementwise_gpr,
	179426	.elementwise_sse,
	179427	.xwordwise_sse,
	179428	.ywordwise_sse,
	179429	.zwordwise_sse,
179071	179430	.reserved_frame,
179072	179431	=> unreachable,
179073		.undef => if (opts.safety) try self.genInlineMemset(
	179432	.undef => if (opts.safety) try cg.genInlineMemset(
179074	179433	dst_ptr_mcv,
179075	179434	src_mcv,
179076	179435	.{ .immediate = abi_size },
...	...	@@ -179085,7 +179444,7 @@ fn genSetMem(
179085	179444	.signed => .s(@truncate(@as(i64, @bitCast(imm)))),
179086	179445	.unsigned => .u(@as(u32, @intCast(imm))),
179087	179446	};
179088		try self.asmMemoryImmediate(
	179447	try cg.asmMemoryImmediate(
179089	179448	.{ ._, .mov },
179090	179449	.{ .base = base, .mod = .{ .rm = .{
179091	179450	.size = .fromSize(abi_size),
...	...	@@ -179096,7 +179455,7 @@ fn genSetMem(
179096	179455	},
179097	179456	3, 5...7 => unreachable,
179098	179457	else => if (std.math.cast(i32, @as(i64, @bitCast(imm)))) \|small\| {
179099		try self.asmMemoryImmediate(
	179458	try cg.asmMemoryImmediate(
179100	179459	.{ ._, .mov },
179101	179460	.{ .base = base, .mod = .{ .rm = .{
179102	179461	.size = .fromSize(abi_size),
...	...	@@ -179106,7 +179465,7 @@ fn genSetMem(
179106	179465	);
179107	179466	} else {
179108	179467	var offset: i32 = 0;
179109		while (offset < abi_size) : (offset += 4) try self.asmMemoryImmediate(
	179468	while (offset < abi_size) : (offset += 4) try cg.asmMemoryImmediate(
179110	179469	.{ ._, .mov },
179111	179470	.{ .base = base, .mod = .{ .rm = .{
179112	179471	.size = .dword,
...	...	@@ -179120,7 +179479,7 @@ fn genSetMem(
179120	179479	);
179121	179480	},
179122	179481	},
179123		.eflags => \|cc\| try self.asmSetccMemory(cc, .{ .base = base, .mod = .{
	179482	.eflags => \|cc\| try cg.asmSetccMemory(cc, .{ .base = base, .mod = .{
179124	179483	.rm = .{ .size = .byte, .disp = disp },
179125	179484	} }),
179126	179485	.register => \|src_reg\| {
...	...	@@ -179128,75 +179487,75 @@ fn genSetMem(
179128	179487	const mem_size = switch (base) {
179129	179488	.frame => \|base_fi\| mem_size: {
179130	179489	assert(disp >= 0);
179131		const frame_abi_size = self.frame_allocs.items(.abi_size)[@intFromEnum(base_fi)];
179132		const frame_spill_pad = self.frame_allocs.items(.spill_pad)[@intFromEnum(base_fi)];
	179490	const frame_abi_size = cg.frame_allocs.items(.abi_size)[@intFromEnum(base_fi)];
	179491	const frame_spill_pad = cg.frame_allocs.items(.spill_pad)[@intFromEnum(base_fi)];
179133	179492	assert(frame_abi_size - frame_spill_pad - disp >= abi_size);
179134	179493	break :mem_size if (frame_abi_size - frame_spill_pad - disp == abi_size) frame_abi_size else abi_size;
179135	179494	},
179136	179495	else => abi_size,
179137	179496	};
179138		const src_alias = registerAlias(src_reg, @intCast(self.unalignedSize(ty)));
179139		const src_class = src_alias.class();
179140		const src_size: Memory.Size = switch (src_class) {
	179497	const src_alias = registerAlias(src_reg, @intCast(cg.unalignedSize(ty)));
	179498	const src_rc = src_alias.class();
	179499	const src_size: Memory.Size = switch (src_rc) {
179141	179500	.general_purpose, .gphi, .segment, .ip, .cr, .dr => src_alias.size(),
179142	179501	.mmx, .sse => .fromSize(abi_size),
179143		.x87 => switch (abi.classifySystemV(ty, zcu, self.target, .other)[0]) {
	179502	.x87 => switch (abi.classifySystemV(ty, zcu, cg.target, .other)[0]) {
179144	179503	else => unreachable,
179145	179504	.float => .dword,
179146	179505	.float_combine, .sse => .qword,
179147	179506	.x87 => .tbyte,
179148	179507	},
179149	179508	};
179150		const src_bit_size = src_size.bitSize(self.target);
	179509	const src_bit_size = src_size.bitSize(cg.target);
179151	179510	const src_align: InternPool.Alignment = .fromNonzeroByteUnits(std.math.ceilPowerOfTwoAssert(u64, src_bit_size));
179152	179511	const src_byte_size = @divExact(src_bit_size, 8);
179153	179512	if (src_byte_size > mem_size) {
179154		const frame_index = try self.allocFrameIndex(.init(.{
	179513	const frame_index = try cg.allocFrameIndex(.init(.{
179155	179514	.size = src_byte_size,
179156	179515	.alignment = src_align,
179157	179516	}));
179158	179517	const frame_mcv: MCValue = .{ .load_frame = .{ .index = frame_index } };
179159		try (try self.moveStrategy(ty, src_class, true)).write(self, .{
	179518	try (try cg.moveStrategy(ty, src_rc, true)).write(cg, .{
179160	179519	.base = .{ .frame = frame_index },
179161	179520	.mod = .{ .rm = .{ .size = src_size } },
179162	179521	}, src_alias);
179163		try self.genSetMem(base, disp, ty, frame_mcv, opts);
179164		try self.freeValue(frame_mcv, .{});
179165		} else try (try self.moveStrategy(ty, src_class, switch (base) {
	179522	try cg.genSetMem(base, disp, ty, frame_mcv, opts);
	179523	try cg.freeValue(frame_mcv, .{});
	179524	} else try (try cg.moveStrategy(ty, src_rc, switch (base) {
179166	179525	.none => src_align.check(@as(u32, @bitCast(disp))),
179167	179526	.reg => \|reg\| switch (reg) {
179168	179527	.es, .cs, .ss, .ds => src_align.check(@as(u32, @bitCast(disp))),
179169	179528	else => false,
179170	179529	},
179171		.frame => \|frame_index\| self.getFrameAddrAlignment(.{
	179530	.frame => \|frame_index\| cg.getFrameAddrAlignment(.{
179172	179531	.index = frame_index,
179173	179532	.off = disp,
179174	179533	}).compare(.gte, src_align),
179175	179534	.table, .rip_inst, .lazy_sym, .extern_func => unreachable,
179176	179535	.nav => \|nav\| ip.getNav(nav).resolved.?.@"align".compare(.gte, src_align),
179177	179536	.uav => \|uav\| Type.fromInterned(uav.orig_ty).ptrAlignment(zcu).compare(.gte, src_align),
179178		})).write(self, .{
	179537	})).write(cg, .{
179179	179538	.base = base,
179180	179539	.mod = .{ .rm = .{ .size = src_size, .disp = disp } },
179181	179540	}, src_alias);
179182	179541	},
179183	179542	inline .register_pair, .register_triple, .register_quadruple => \|src_regs\| {
179184	179543	var part_disp: i32 = disp;
179185		for (try self.splitType(src_regs.len, ty), src_regs) \|src_ty, src_reg\| {
179186		try self.genSetMem(base, part_disp, src_ty, .{ .register = src_reg }, opts);
179187		part_disp += @intCast(src_ty.abiSize(zcu));
	179544	for (try cg.splitType(src_regs.len, ty), src_regs) \|src_ty, src_reg\| {
	179545	try cg.genSetMem(base, part_disp, src_ty, .{ .register = src_reg }, opts);
	179546	part_disp += @intCast(cg.unalignedSize(src_ty));
179188	179547	}
179189	179548	},
179190	179549	.register_overflow => \|ro\| switch (ty.zigTypeTag(zcu)) {
179191	179550	.@"struct" => {
179192		try self.genSetMem(
	179551	try cg.genSetMem(
179193	179552	base,
179194	179553	disp + @as(i32, @intCast(ty.structFieldOffset(0, zcu))),
179195	179554	ty.fieldType(0, zcu),
179196	179555	.{ .register = ro.reg },
179197	179556	opts,
179198	179557	);
179199		try self.genSetMem(
	179558	try cg.genSetMem(
179200	179559	base,
179201	179560	disp + @as(i32, @intCast(ty.structFieldOffset(1, zcu))),
179202	179561	ty.fieldType(1, zcu),
...	...	@@ -179207,8 +179566,8 @@ fn genSetMem(
179207	179566	.optional => {
179208	179567	assert(!ty.optionalReprIsPayload(zcu));
179209	179568	const child_ty = ty.optionalChild(zcu);
179210		try self.genSetMem(base, disp, child_ty, .{ .register = ro.reg }, opts);
179211		try self.genSetMem(
	179569	try cg.genSetMem(base, disp, child_ty, .{ .register = ro.reg }, opts);
	179570	try cg.genSetMem(
179212	179571	base,
179213	179572	disp + @as(i32, @intCast(child_ty.abiSize(zcu))),
179214	179573	.bool,
...	...	@@ -179216,37 +179575,37 @@ fn genSetMem(
179216	179575	opts,
179217	179576	);
179218	179577	},
179219		else => return self.fail("TODO implement genSetMem for {s} of {f}", .{
	179578	else => return cg.fail("TODO implement genSetMem for {s} of {f}", .{
179220	179579	@tagName(src_mcv), ty.fmt(pt),
179221	179580	}),
179222	179581	},
179223	179582	.register_offset => \|reg_off\| {
179224		const src_reg = self.copyToTmpRegister(ty, src_mcv) catch \|err\| switch (err) {
	179583	const src_reg = cg.copyToTmpRegister(ty, src_mcv) catch \|err\| switch (err) {
179225	179584	error.OutOfRegisters => {
179226		const src_reg = registerAlias(reg_off.reg, abi_size);
179227		try self.asmRegisterMemory(.{ ._, .lea }, src_reg, .{
179228		.base = .{ .reg = src_reg },
	179585	const src_alias = registerAlias(reg_off.reg, @intCast(cg.unalignedSize(ty)));
	179586	try cg.asmRegisterMemory(.{ ._, .lea }, src_alias, .{
	179587	.base = .{ .reg = src_alias },
179229	179588	.mod = .{ .rm = .{ .disp = reg_off.off } },
179230	179589	});
179231		try self.genSetMem(base, disp, ty, .{ .register = reg_off.reg }, opts);
179232		return self.asmRegisterMemory(.{ ._, .lea }, src_reg, .{
179233		.base = .{ .reg = src_reg },
	179590	try cg.genSetMem(base, disp, ty, .{ .register = reg_off.reg }, opts);
	179591	return cg.asmRegisterMemory(.{ ._, .lea }, src_alias, .{
	179592	.base = .{ .reg = src_alias },
179234	179593	.mod = .{ .rm = .{ .disp = -reg_off.off } },
179235	179594	});
179236	179595	},
179237	179596	else => \|e\| return e,
179238	179597	};
179239		const src_lock = self.register_manager.lockRegAssumeUnused(src_reg);
179240		defer self.register_manager.unlockReg(src_lock);
	179598	const src_lock = cg.register_manager.lockRegAssumeUnused(src_reg);
	179599	defer cg.register_manager.unlockReg(src_lock);
179241	179600
179242		try self.genSetMem(base, disp, ty, .{ .register = src_reg }, opts);
	179601	try cg.genSetMem(base, disp, ty, .{ .register = src_reg }, opts);
179243	179602	},
179244	179603	.register_mask => {
179245		const src_reg = try self.copyToTmpRegister(ty, src_mcv);
179246		const src_lock = self.register_manager.lockRegAssumeUnused(src_reg);
179247		defer self.register_manager.unlockReg(src_lock);
	179604	const src_reg = try cg.copyToTmpRegister(ty, src_mcv);
	179605	const src_lock = cg.register_manager.lockRegAssumeUnused(src_reg);
	179606	defer cg.register_manager.unlockReg(src_lock);
179248	179607
179249		try self.genSetMem(base, disp, ty, .{ .register = src_reg }, opts);
	179608	try cg.genSetMem(base, disp, ty, .{ .register = src_reg }, opts);
179250	179609	},
179251	179610	.memory,
179252	179611	.indirect,
...	...	@@ -179263,15 +179622,15 @@ fn genSetMem(
179263	179622	=> switch (abi_size) {
179264	179623	0 => {},
179265	179624	1, 2, 4, 8 => {
179266		const src_reg = try self.copyToTmpRegister(ty, src_mcv);
179267		const src_lock = self.register_manager.lockRegAssumeUnused(src_reg);
179268		defer self.register_manager.unlockReg(src_lock);
	179625	const src_reg = try cg.copyToTmpRegister(ty, src_mcv);
	179626	const src_lock = cg.register_manager.lockRegAssumeUnused(src_reg);
	179627	defer cg.register_manager.unlockReg(src_lock);
179269	179628
179270		try self.genSetMem(base, disp, ty, .{ .register = src_reg }, opts);
	179629	try cg.genSetMem(base, disp, ty, .{ .register = src_reg }, opts);
179271	179630	},
179272		else => try self.genInlineMemcpy(dst_ptr_mcv, src_mcv.address(), .{ .immediate = abi_size }, .{ .no_alias = true }),
	179631	else => try cg.genInlineMemcpy(dst_ptr_mcv, src_mcv.address(), .{ .immediate = abi_size }, .{ .no_alias = true }),
179273	179632	},
179274		.air_ref => \|src_ref\| try self.genSetMem(base, disp, ty, try self.resolveInst(src_ref), opts),
	179633	.air_ref => \|src_ref\| try cg.genSetMem(base, disp, ty, try cg.resolveInst(src_ref), opts),
179275	179634	}
179276	179635	}
179277	179636
...	...	@@ -179780,7 +180139,7 @@ fn atomicOp(
179780	180139	mir_tag,
179781	180140	sse_reg.to128(),
179782	180141	sse_reg.to128(),
179783		try val_mcv.mem(self, .{ .size = self.memSize(val_ty) }),
	180142	try val_mcv.mem(self, .{ .size = self.memSize(val_ty, sse_reg.class()) }),
179784	180143	) else try self.asmRegisterRegisterRegister(
179785	180144	mir_tag,
179786	180145	sse_reg.to128(),
...	...	@@ -179793,7 +180152,7 @@ fn atomicOp(
179793	180152	._ss, ._sd => if (val_mcv.isBase()) try self.asmRegisterMemory(
179794	180153	mir_tag,
179795	180154	sse_reg.to128(),
179796		try val_mcv.mem(self, .{ .size = self.memSize(val_ty) }),
	180155	try val_mcv.mem(self, .{ .size = self.memSize(val_ty, sse_reg.class()) }),
179797	180156	) else try self.asmRegisterRegister(
179798	180157	mir_tag,
179799	180158	sse_reg.to128(),
...	...	@@ -180369,7 +180728,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void {
180369	180728	mir_tag,
180370	180729	dst_alias,
180371	180730	rhs_alias,
180372		try other_mcv.mem(self, .{ .size = self.memSize(ty) }),
	180731	try other_mcv.mem(self, .{ .size = self.memSize(ty, dst_reg.class()) }),
180373	180732	mask_alias,
180374	180733	) else try self.asmRegisterRegisterRegisterRegister(
180375	180734	mir_tag,
...	...	@@ -180384,7 +180743,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void {
180384	180743	} else if (has_blend) if (other_mcv.isBase()) try self.asmRegisterMemoryRegister(
180385	180744	mir_tag,
180386	180745	dst_alias,
180387		try other_mcv.mem(self, .{ .size = self.memSize(ty) }),
	180746	try other_mcv.mem(self, .{ .size = self.memSize(ty, dst_reg.class()) }),
180388	180747	mask_alias,
180389	180748	) else try self.asmRegisterRegisterRegister(
180390	180749	mir_tag,
...	...	@@ -180527,7 +180886,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void {
180527	180886	} })));
180528	180887	const mask_mem: Memory = .{
180529	180888	.base = .{ .reg = try self.copyToTmpRegister(.usize, mask_mcv.address()) },
180530		.mod = .{ .rm = .{ .size = self.memSize(ty) } },
	180889	.mod = .{ .rm = .{ .size = self.memSize(ty, mask_reg.class()) } },
180531	180890	};
180532	180891	if (has_avx) try self.asmRegisterRegisterMemory(
180533	180892	.{ .vp_b, .shuf },
...	...	@@ -180552,7 +180911,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void {
180552	180911	const mask_mcv = try self.lowerValue(try pt.aggregateValue(mask_ty, mask_elems));
180553	180912	const mask_mem: Memory = .{
180554	180913	.base = .{ .reg = try self.copyToTmpRegister(.usize, mask_mcv.address()) },
180555		.mod = .{ .rm = .{ .size = self.memSize(ty) } },
	180914	.mod = .{ .rm = .{ .size = self.memSize(ty, mask_reg.class()) } },
180556	180915	};
180557	180916	if (has_avx) {
180558	180917	try self.asmRegisterRegisterMemory(
...	...	@@ -180671,7 +181030,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void {
180671	181030	mir_tag,
180672	181031	dst_alias,
180673	181032	rhs_alias,
180674		try lhs_mcv.mem(self, .{ .size = self.memSize(ty) }),
	181033	try lhs_mcv.mem(self, .{ .size = self.memSize(ty, dst_reg.class()) }),
180675	181034	mask_alias,
180676	181035	) else try self.asmRegisterRegisterRegisterRegister(
180677	181036	mir_tag,
...	...	@@ -180686,7 +181045,7 @@ fn airSelect(self: *CodeGen, inst: Air.Inst.Index) !void {
180686	181045	} else if (has_blend) if (lhs_mcv.isBase()) try self.asmRegisterMemoryRegister(
180687	181046	mir_tag,
180688	181047	dst_alias,
180689		try lhs_mcv.mem(self, .{ .size = self.memSize(ty) }),
	181048	try lhs_mcv.mem(self, .{ .size = self.memSize(ty, dst_reg.class()) }),
180690	181049	mask_alias,
180691	181050	) else try self.asmRegisterRegisterRegister(
180692	181051	mir_tag,
...	...	@@ -181205,9 +181564,9 @@ fn resolveCallingConventionValues(
181205	181564	result.stack_align = .fromByteUnits(cc_opts.incoming_stack_alignment orelse 16);
181206	181565
181207	181566	switch (cc) {
	181567	else => unreachable,
181208	181568	.x86_64_sysv => {},
181209	181569	.x86_64_win => result.stack_byte_count += @intCast(win64_shadow_space),
181210		else => unreachable,
181211	181570	}
181212	181571
181213	181572	// Return values
...	...	@@ -181223,10 +181582,17 @@ fn resolveCallingConventionValues(
181223	181582	var ret_sse = abi.getCAbiSseReturnRegs(cc);
181224	181583	var ret_x87 = abi.getCAbiX87ReturnRegs(cc);
181225	181584
181226		const classes: []const abi.Class = switch (cc) {
181227		.x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ret_ty, zcu, cg.target, .ret), .none),
181228		.x86_64_win => &.{abi.classifyWindows(ret_ty, zcu, cg.target, .ret)},
	181585	var classes_buf: [8]abi.Class = undefined;
	181586	const classes = classes: switch (cc) {
181229	181587	else => unreachable,
	181588	.x86_64_sysv => {
	181589	classes_buf = abi.classifySystemV(ret_ty, zcu, cg.target, .ret);
	181590	break :classes std.mem.sliceTo(&classes_buf, .none);
	181591	},
	181592	.x86_64_win => {
	181593	classes_buf[0] = abi.classifyWindows(ret_ty, zcu, cg.target, .ret);
	181594	break :classes classes_buf[0..1];
	181595	},
181230	181596	};
181231	181597	for (classes) \|class\| switch (class) {
181232	181598	.integer => {
...	...	@@ -181238,16 +181604,11 @@ fn resolveCallingConventionValues(
181238	181604	ret_gpr = ret_gpr[1..];
181239	181605	},
181240	181606	.sse, .float, .float_combine, .win_i128 => {
181241		const abi_size: u32 = @intCast(ret_ty.abiSize(zcu));
181242		const reg_size = @min(abi_size, cg.vectorSize(.float));
181243		var byte_offset: u32 = 0;
181244		while (byte_offset < abi_size) : (byte_offset += reg_size) {
181245		const ret_sse_reg = registerAlias(ret_sse[0], reg_size);
181246		ret_sse = ret_sse[1..];
181247
181248		ret_tracking[ret_tracking_len] = .init(.{ .register = ret_sse_reg });
181249		ret_tracking_len += 1;
181250		}
	181607	ret_tracking[ret_tracking_len] = .init(.{
	181608	.register = registerAlias(ret_sse[0], @intCast(ret_ty.abiSize(zcu))),
	181609	});
	181610	ret_tracking_len += 1;
	181611	ret_sse = ret_sse[1..];
181251	181612	},
181252	181613	.sseup => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.sse)),
181253	181614	.x87 => {
...	...	@@ -181256,7 +181617,8 @@ fn resolveCallingConventionValues(
181256	181617	ret_x87 = ret_x87[1..];
181257	181618	},
181258	181619	.x87up => assert(ret_tracking[ret_tracking_len - 1].short.register.isClass(.x87)),
181259		.memory, .integer_per_element => {
	181620	.none => unreachable,
	181621	.memory => {
181260	181622	ret_tracking[ret_tracking_len] = .{
181261	181623	.short = .{ .indirect = .{ .reg = ret_gpr[0].to64() } },
181262	181624	.long = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } },
...	...	@@ -181265,7 +181627,59 @@ fn resolveCallingConventionValues(
181265	181627	ret_gpr = ret_gpr[1..];
181266	181628	param_gpr_index += 1;
181267	181629	},
181268		.none => unreachable,
	181630	.integer_per_element => {
	181631	const len: u32 = @intCast(ret_ty.vectorLen(zcu));
	181632	const alias_size: u32 = @intCast(@min(ret_ty.childType(zcu).abiSize(zcu), 8));
	181633	for (ret_tracking[ret_tracking_len..][0..len], ret_gpr[0..len]) \|*tracking, gpr\|
	181634	tracking.* = .init(.{ .register = registerAlias(gpr, alias_size) });
	181635	ret_tracking_len += len;
	181636	ret_gpr = ret_gpr[len..];
	181637	},
	181638	.sse_per_element => {
	181639	const len: u32 = @intCast(ret_ty.vectorLen(zcu));
	181640	const alias_size: u32 = @intCast(@min(ret_ty.childType(zcu).abiSize(zcu), 8));
	181641	for (ret_tracking[ret_tracking_len..][0..len], ret_sse[0..len]) \|*tracking, sse\|
	181642	tracking.* = .init(.{ .register = registerAlias(sse, alias_size) });
	181643	ret_tracking_len += len;
	181644	ret_sse = ret_sse[len..];
	181645	},
	181646	.sse_sse_x87_per_qword, .sse_per_xword, .sse_per_yword, .sse_per_zword => {
	181647	const reg_size: u32 = switch (class) {
	181648	else => unreachable,
	181649	.sse_sse_x87_per_qword => 8,
	181650	.sse_per_xword => 16,
	181651	.sse_per_yword => 32,
	181652	.sse_per_zword => 64,
	181653	};
	181654	var byte_offset: u32 = 0;
	181655	const unaligned_size = cg.unalignedSize(ret_ty);
	181656	while (byte_offset < unaligned_size) : (byte_offset += reg_size) {
	181657	switch (@as(enum { sse, x87 }, switch (class) {
	181658	else => unreachable,
	181659	.sse_sse_x87_per_qword => switch (byte_offset) {
	181660	0 => .sse, // duck
	181661	8 => .sse, // duck
	181662	else => .x87, // goose!
	181663	},
	181664	.sse_per_xword, .sse_per_yword, .sse_per_zword => .sse,
	181665	})) {
	181666	.sse => {
	181667	ret_tracking[ret_tracking_len] = .init(.{
	181668	.register = registerAlias(ret_sse[0], reg_size),
	181669	});
	181670	ret_tracking_len += 1;
	181671	ret_sse = ret_sse[1..];
	181672	},
	181673	.x87 => {
	181674	ret_tracking[ret_tracking_len] = .init(.{
	181675	.register = registerAlias(ret_x87[0], reg_size),
	181676	});
	181677	ret_tracking_len += 1;
	181678	ret_x87 = ret_x87[1..];
	181679	},
	181680	}
	181681	}
	181682	},
181269	181683	};
181270	181684	result.return_value = switch (ret_tracking_len) {
181271	181685	else => unreachable,
...	...	@@ -181293,12 +181707,12 @@ fn resolveCallingConventionValues(
181293	181707	assert(ty.hasRuntimeBits(zcu));
181294	181708	result.air_arg_count += 1;
181295	181709	switch (cc) {
	181710	else => unreachable,
181296	181711	.x86_64_sysv => {},
181297	181712	.x86_64_win => {
181298	181713	param_gpr_index = @max(param_gpr_index, param_sse_index);
181299	181714	param_sse_index = param_gpr_index;
181300	181715	},
181301		else => unreachable,
181302	181716	}
181303	181717
181304	181718	const save_param_gpr_index = param_gpr_index;
...	...	@@ -181307,17 +181721,25 @@ fn resolveCallingConventionValues(
181307	181721	var arg_mcv: [4]MCValue = undefined;
181308	181722	var arg_mcv_len: u32 = 0;
181309	181723
181310		const classes = switch (cc) {
181311		.x86_64_sysv => std.mem.sliceTo(&abi.classifySystemV(ty, zcu, cg.target, .arg), .none),
181312		.x86_64_win => &.{abi.classifyWindows(ty, zcu, cg.target, .arg)},
	181724	var classes_buf: [8]abi.Class = undefined;
	181725	const classes = classes: switch (cc) {
181313	181726	else => unreachable,
	181727	.x86_64_sysv => {
	181728	classes_buf = abi.classifySystemV(ty, zcu, cg.target, .arg);
	181729	break :classes std.mem.sliceTo(&classes_buf, .none);
	181730	},
	181731	.x86_64_win => {
	181732	classes_buf[0] = abi.classifyWindows(ty, zcu, cg.target, .arg);
	181733	break :classes classes_buf[0..1];
	181734	},
181314	181735	};
181315	181736	classes: for (classes) \|class\| switch (class) {
181316	181737	.integer => {
181317	181738	if (param_gpr_index >= param_gpr.len) break;
181318		arg_mcv[arg_mcv_len] = .{
181319		.register = registerAlias(param_gpr[param_gpr_index], @intCast(@min(ty.abiSize(zcu), 8))),
181320		};
	181739	arg_mcv[arg_mcv_len] = .{ .register = registerAlias(
	181740	param_gpr[param_gpr_index],
	181741	@intCast(@min(ty.abiSize(zcu), 8)),
	181742	) };
181321	181743	arg_mcv_len += 1;
181322	181744	param_gpr_index += 1;
181323	181745	},
...	...	@@ -181338,48 +181760,93 @@ fn resolveCallingConventionValues(
181338	181760	.sseup => assert(arg_mcv[arg_mcv_len - 1].register.isClass(.sse)),
181339	181761	.x87, .x87up, .memory, .win_i128 => switch (cc) {
181340	181762	.x86_64_sysv => switch (class) {
181341		.x87, .x87up, .memory => break,
181342	181763	else => unreachable,
	181764	.x87, .x87up, .memory => break,
	181765	},
	181766	.x86_64_win => if (param_gpr_index < param_gpr.len) {
	181767	arg_mcv[arg_mcv_len] = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } };
	181768	arg_mcv_len += 1;
	181769	param_gpr_index += 1;
	181770	} else {
	181771	assert(arg_mcv_len == 0);
	181772	const param_align = Type.usize.abiAlignment(zcu);
	181773	result.stack_byte_count = @intCast(param_align.forward(result.stack_byte_count));
	181774	result.stack_align = result.stack_align.max(param_align);
	181775	arg.* = .{ .indirect_load_frame = .{
	181776	.index = stack_frame_base,
	181777	.off = result.stack_byte_count,
	181778	} };
	181779	result.stack_byte_count += @intCast(Type.usize.abiSize(zcu));
	181780	continue :params;
181343	181781	},
181344		.x86_64_win => if (ty.abiSize(zcu) > 8) {
181345		if (param_gpr_index < param_gpr.len) {
181346		arg_mcv[arg_mcv_len] = .{ .indirect = .{ .reg = param_gpr[param_gpr_index].to64() } };
181347		arg_mcv_len += 1;
181348		param_gpr_index += 1;
181349		} else {
181350		assert(arg_mcv_len == 0);
181351		const param_align = Type.usize.abiAlignment(zcu);
181352		result.stack_byte_count = @intCast(param_align.forward(result.stack_byte_count));
181353		result.stack_align = result.stack_align.max(param_align);
181354		arg.* = .{ .indirect_load_frame = .{
181355		.index = stack_frame_base,
181356		.off = result.stack_byte_count,
181357		} };
181358		result.stack_byte_count += @intCast(Type.usize.abiSize(zcu));
181359		continue :params;
181360		}
181361		} else break,
181362	181782	else => unreachable,
181363	181783	},
181364	181784	.none => unreachable,
181365		.integer_per_element => {
181366		const remaining_param_gpr_len: u3 = @intCast(param_gpr.len - param_gpr_index);
181367		param_gpr_index = @intCast(param_gpr.len);
181368
	181785	.integer_per_element,
	181786	.sse_per_element,
	181787	.sse_per_xword,
	181788	.sse_per_yword,
	181789	.sse_per_zword,
	181790	=> {
	181791	const len = switch (class) {
	181792	else => unreachable,
	181793	.integer_per_element, .sse_per_element => ty.vectorLen(zcu),
	181794	.sse_per_xword => @divExact(ty.abiSize(zcu), 16),
	181795	.sse_per_yword => @divExact(ty.abiSize(zcu), 32),
	181796	.sse_per_zword => @divExact(ty.abiSize(zcu), 64),
	181797	};
	181798	const param_reg_len: u32 = @intCast(@min(len, switch (class) {
	181799	else => unreachable,
	181800	.integer_per_element => param_gpr.len - param_gpr_index,
	181801	.sse_per_element,
	181802	.sse_per_xword,
	181803	.sse_per_yword,
	181804	.sse_per_zword,
	181805	=> param_sse.len - param_sse_index,
	181806	}));
	181807	const frame_elem_len = len - param_reg_len;
181369	181808	const frame_elem_align = 8;
181370		const frame_elems_len = ty.vectorLen(zcu) - remaining_param_gpr_len;
181371		const frame_elem_size = std.mem.alignForward(u64, ty.childType(zcu).abiSize(zcu), frame_elem_align);
181372		const frame_size: u31 = @intCast(frame_elems_len * frame_elem_size);
181373
181374		result.stack_byte_count = std.mem.alignForward(u31, result.stack_byte_count, frame_elem_align);
181375		arg_mcv[arg_mcv_len] = .{ .elementwise_args = .{
181376		.regs = remaining_param_gpr_len,
181377		.frame_off = @intCast(result.stack_byte_count),
	181809	const frame_elem_size = switch (class) {
	181810	else => unreachable,
	181811	.integer_per_element, .sse_per_element => std.mem.alignForward(
	181812	u64,
	181813	ty.childType(zcu).abiSize(zcu),
	181814	frame_elem_align,
	181815	),
	181816	.sse_per_xword, .sse_per_yword, .sse_per_zword => 8,
	181817	};
	181818	const frame_size: u31 = @intCast(frame_elem_size * frame_elem_len);
	181819
	181820	if (frame_size > 0) result.stack_byte_count =
	181821	std.mem.alignForward(u31, result.stack_byte_count, frame_elem_align);
	181822	const info: ArgsInfo = .{
	181823	.info = .{
	181824	.reg_index = @intCast(param_gpr_index),
	181825	.frame_off = @intCast(result.stack_byte_count),
	181826	},
181378	181827	.frame_index = stack_frame_base,
181379		} };
	181828	};
	181829	arg_mcv[arg_mcv_len] = switch (class) {
	181830	else => unreachable,
	181831	.integer_per_element => .{ .elementwise_gpr = info },
	181832	.sse_per_element => .{ .elementwise_sse = info },
	181833	.sse_per_xword => .{ .xwordwise_sse = info },
	181834	.sse_per_yword => .{ .ywordwise_sse = info },
	181835	.sse_per_zword => .{ .zwordwise_sse = info },
	181836	};
181380	181837	arg_mcv_len += 1;
	181838	switch (class) {
	181839	else => unreachable,
	181840	.integer_per_element => param_gpr_index += param_reg_len,
	181841	.sse_per_element,
	181842	.sse_per_xword,
	181843	.sse_per_yword,
	181844	.sse_per_zword,
	181845	=> param_sse_index += param_reg_len,
	181846	}
181381	181847	result.stack_byte_count += frame_size;
181382	181848	},
	181849	.sse_sse_x87_per_qword => unreachable, // thank goodness
181383	181850	} else {
181384	181851	arg.* = switch (arg_mcv_len) {
181385	181852	else => unreachable,
...	...	@@ -181593,14 +182060,17 @@ fn registerAlias(reg: Register, size_bytes: u32) Register {
181593	182060	};
181594	182061	}
181595	182062
181596		fn memSize(self: *CodeGen, ty: Type) Memory.Size {
	182063	fn memSize(self: *CodeGen, ty: Type, class: Register.Class) Memory.Size {
181597	182064	const zcu = self.pt.zcu;
181598	182065	return if (self.floatBits(ty)) \|float_bits\|
181599	182066	.fromBitSize(float_bits)
181600	182067	else if (ty.isVector(zcu) and ty.vectorLen(zcu) == 1 and self.floatBits(ty.childType(zcu)) == 80)
181601	182068	.tbyte
181602	182069	else
181603		.fromSize(@intCast(ty.abiSize(zcu)));
	182070	.fromSize(@intCast(switch (class) {
	182071	.general_purpose, .gphi, .segment, .x87, .ip, .cr, .dr => self.unalignedSize(ty),
	182072	.mmx, .sse => ty.abiSize(zcu),
	182073	}));
181604	182074	}
181605	182075
181606	182076	fn splitType(self: *CodeGen, comptime parts_len: usize, ty: Type) ![parts_len]Type {
...	...	@@ -181610,7 +182080,10 @@ fn splitType(self: *CodeGen, comptime parts_len: usize, ty: Type) ![parts_len]Ty
181610	182080	var parts: [parts_len]Type = undefined;
181611	182081	switch (ip.indexToKey(ty.toIntern())) {
181612	182082	.vector_type => \|vector_type\| if (std.math.divExact(u32, vector_type.len, parts_len)) \|vec_len\| {
181613		return @splat(try pt.vectorType(.{ .len = vec_len, .child = vector_type.child }));
	182083	return @splat(switch (vec_len) {
	182084	1 => .fromInterned(vector_type.child),
	182085	else => try pt.vectorType(.{ .len = vec_len, .child = vector_type.child }),
	182086	});
181614	182087	} else \|err\| switch (err) {
181615	182088	error.DivisionByZero => unreachable,
181616	182089	error.UnexpectedRemainder => {},
...	...	@@ -181951,7 +182424,11 @@ const Temp = struct {
181951	182424	.lea_lazy_sym,
181952	182425	.lea_extern_func,
181953	182426	.load_extern_func,
181954		.elementwise_args,
	182427	.elementwise_gpr,
	182428	.elementwise_sse,
	182429	.xwordwise_sse,
	182430	.ywordwise_sse,
	182431	.zwordwise_sse,
181955	182432	.reserved_frame,
181956	182433	.air_ref,
181957	182434	=> false,
...	...	@@ -182414,7 +182891,11 @@ const Temp = struct {
182414	182891	.register_overflow,
182415	182892	.register_mask,
182416	182893	.indirect_load_frame,
182417		.elementwise_args,
	182894	.elementwise_gpr,
	182895	.elementwise_sse,
	182896	.xwordwise_sse,
	182897	.ywordwise_sse,
	182898	.zwordwise_sse,
182418	182899	.reserved_frame,
182419	182900	.air_ref,
182420	182901	=> unreachable, // not a valid pointer
...	...	@@ -182546,7 +183027,7 @@ const Temp = struct {
182546	183027	try cg.asmMemoryImmediate(
182547	183028	.{ ._, .mov },
182548	183029	try ptr.tracking(cg).short.deref().mem(cg, .{
182549		.size = cg.memSize(val_ty),
	183030	.size = cg.memSize(val_ty, .general_purpose),
182550	183031	}),
182551	183032	val_op,
182552	183033	);
...	...	@@ -182566,10 +183047,9 @@ const Temp = struct {
182566	183047	try ptr.tracking(cg).short.deref().mem(cg, .{ .size = .byte }),
182567	183048	);
182568	183049	},
182569		.register => \|val_reg\| try ptr.storeRegs(val_ty, &.{registerAlias(
182570		val_reg,
182571		@intCast(val_ty.abiSize(cg.pt.zcu)),
182572		)}, cg),
	183050	.register => \|val_reg\| try ptr.storeRegs(val_ty, &.{
	183051	registerAlias(val_reg, @intCast(cg.unalignedSize(val_ty))),
	183052	}, cg),
182573	183053	inline .register_pair,
182574	183054	.register_triple,
182575	183055	.register_quadruple,
...	...	@@ -182679,14 +183159,10 @@ const Temp = struct {
182679	183159	.s(val_simm32)
182680	183160	else
182681	183161	continue :val_to_gpr;
182682		try cg.asmMemoryImmediate(
182683		.{ ._, .mov },
182684		try dst.tracking(cg).short.mem(cg, .{
182685		.size = cg.memSize(val_ty),
182686		.disp = opts.disp,
182687		}),
182688		val_op,
182689		);
	183162	try cg.asmMemoryImmediate(.{ ._, .mov }, try dst.tracking(cg).short.mem(cg, .{
	183163	.size = cg.memSize(val_ty, .general_purpose),
	183164	.disp = opts.disp,
	183165	}), val_op);
182690	183166	},
182691	183167	.eflags => \|cc\| try cg.asmSetccMemory(
182692	183168	cc,
...	...	@@ -182758,7 +183234,7 @@ const Temp = struct {
182758	183234	while (try ptr.toRegClass(false, .general_purpose, cg)) {},
182759	183235	}
182760	183236	try strat.read(cg, dst_reg, try ptr.tracking(cg).short.deref().mem(cg, .{
182761		.size = cg.memSize(dst_ty),
	183237	.size = cg.memSize(dst_ty, dst_rc),
182762	183238	}));
182763	183239	}
182764	183240
...	...	@@ -182767,7 +183243,9 @@ const Temp = struct {
182767	183243	const ip = &zcu.intern_pool;
182768	183244	var part_disp: u31 = 0;
182769	183245	var deferred_disp: u31 = 0;
182770		var src_abi_size: u32 = @intCast(src_ty.abiSize(cg.pt.zcu));
	183246	const is_full = src_regs.len == 1 and
	183247	(src_regs[0].class() == .sse or !(src_ty.isRuntimeFloat() or src_ty.isVector(zcu)));
	183248	var src_size: u32 = @intCast(if (is_full) src_ty.abiSize(zcu) else cg.unalignedSize(src_ty));
182771	183249	for (src_regs, 0..) \|src_reg, part_index\| {
182772	183250	const part_ty: Type = if (src_regs.len == 1)
182773	183251	src_ty
...	...	@@ -182782,13 +183260,17 @@ const Temp = struct {
182782	183260	break :part_ty .usize;
182783	183261	},
182784	183262	.array_type => {
182785		assert(src_regs.len - part_index == std.math.divCeil(u32, src_abi_size, 8) catch unreachable);
182786		break :part_ty try cg.pt.intType(.unsigned, @as(u16, 8) * @min(src_abi_size, 8));
	183263	assert(src_regs.len - part_index == std.math.divCeil(u32, src_size, 8) catch unreachable);
	183264	break :part_ty try cg.pt.intType(.unsigned, @as(u16, 8) * @min(src_size, 8));
	183265	},
	183266	.vector_type => \|vector_type\| switch (@divExact(vector_type.len, src_regs.len)) {
	183267	0 => unreachable,
	183268	1 => .fromInterned(vector_type.child),
	183269	else => \|len\| try cg.pt.vectorType(.{
	183270	.len = @intCast(len),
	183271	.child = vector_type.child,
	183272	}),
182787	183273	},
182788		.vector_type => \|vector_type\| try cg.pt.vectorType(.{
182789		.len = @intCast(@divExact(vector_type.len, src_regs.len)),
182790		.child = vector_type.child,
182791		}),
182792	183274	.opt_type => \|opt_child\| switch (ip.indexToKey(opt_child)) {
182793	183275	else => std.debug.panic("{s}: {f}\n", .{ @src().fn_name, src_ty.fmt(cg.pt) }),
182794	183276	.ptr_type => \|ptr_info\| {
...	...	@@ -182798,8 +183280,8 @@ const Temp = struct {
182798	183280	},
182799	183281	},
182800	183282	.struct_type, .union_type => {
182801		assert(src_regs.len - part_index == std.math.divCeil(u32, src_abi_size, 8) catch unreachable);
182802		break :part_ty switch (src_abi_size) {
	183283	assert(src_regs.len - part_index == std.math.divCeil(u32, src_size, 8) catch unreachable);
	183284	break :part_ty switch (src_size) {
182803	183285	0, 3, 5...7 => unreachable,
182804	183286	1 => .u8,
182805	183287	2 => .u16,
...	...	@@ -182812,7 +183294,8 @@ const Temp = struct {
182812	183294	break :part_ty .fromInterned(tuple_type.types.get(ip)[part_index]);
182813	183295	},
182814	183296	};
182815		const part_size: u31 = @intCast(part_ty.abiSize(zcu));
	183297	const part_size: u31 =
	183298	@intCast(if (is_full) part_ty.abiSize(zcu) else cg.unalignedSize(part_ty));
182816	183299	const src_rc = src_reg.class();
182817	183300	if (src_rc == .x87 or std.math.isPowerOfTwo(part_size)) {
182818	183301	// hack around linker relocation bugs
...	...	@@ -182827,8 +183310,9 @@ const Temp = struct {
182827	183310	.x87 => switch (abi.classifySystemV(src_ty, zcu, cg.target, .other)[part_index]) {
182828	183311	else => unreachable,
182829	183312	.float => .dword,
182830		.float_combine, .sse => .qword,
182831		.x87 => .tbyte,
	183313	.float_combine, .sse, .sseup => .qword,
	183314	.x87, .x87up => .tbyte,
	183315	.none => .fromBitSize(8 * part_size),
182832	183316	},
182833	183317	},
182834	183318	.disp = part_disp,
...	...	@@ -182847,19 +183331,20 @@ const Temp = struct {
182847	183331	try ptr.toOffset(deferred_disp, cg);
182848	183332	deferred_disp = 0;
182849	183333	var src_ptr = try cg.tempInit(.usize, .{ .lea_frame = .{ .index = frame_index } });
182850		try ptr.memcpy(&src_ptr, src_abi_size, cg);
	183334	try ptr.memcpy(&src_ptr, src_size, cg);
182851	183335	try src_ptr.die(cg);
182852	183336	}
182853	183337	part_disp += part_size;
182854	183338	deferred_disp += part_size;
182855		src_abi_size -= part_size;
	183339	src_size -= part_size;
182856	183340	}
182857	183341	}
182858	183342
182859	183343	fn readReg(src: Temp, disp: i32, dst_ty: Type, dst_reg: Register, cg: *CodeGen) InnerError!void {
182860		const strat = try cg.moveStrategy(dst_ty, dst_reg.class(), false);
	183344	const dst_rc = dst_reg.class();
	183345	const strat = try cg.moveStrategy(dst_ty, dst_rc, false);
182861	183346	try strat.read(cg, dst_reg, try src.tracking(cg).short.mem(cg, .{
182862		.size = cg.memSize(dst_ty),
	183347	.size = cg.memSize(dst_ty, dst_rc),
182863	183348	.disp = disp,
182864	183349	}));
182865	183350	}
...	...	@@ -182870,7 +183355,7 @@ const Temp = struct {
182870	183355	if (src_rc == .x87 or std.math.isPowerOfTwo(src_abi_size)) {
182871	183356	const strat = try cg.moveStrategy(src_ty, src_rc, false);
182872	183357	try strat.write(cg, try dst.tracking(cg).short.mem(cg, .{
182873		.size = cg.memSize(src_ty),
	183358	.size = cg.memSize(src_ty, src_rc),
182874	183359	.disp = disp,
182875	183360	}), registerAlias(src_reg, src_abi_size));
182876	183361	} else {
...	...	@@ -182906,14 +183391,34 @@ const Temp = struct {
182906	183391	.integer, .memory, .float, .float_combine => class_index + 1,
182907	183392	.sse => std.mem.indexOfNonePos(abi.Class, classes, class_index + 1, &.{.sseup}) orelse classes.len,
182908	183393	.x87 => std.mem.indexOfNonePos(abi.Class, classes, class_index + 1, &.{.x87up}) orelse classes.len,
182909		.sseup, .x87up, .none, .win_i128, .integer_per_element => unreachable,
	183394	.sseup,
	183395	.x87up,
	183396	.none,
	183397	.win_i128,
	183398	.integer_per_element,
	183399	.sse_per_element,
	183400	.sse_sse_x87_per_qword,
	183401	.sse_per_xword,
	183402	.sse_per_yword,
	183403	.sse_per_zword,
	183404	=> unreachable,
182910	183405	});
182911	183406	const part_size = switch (class) {
182912	183407	.integer, .sse, .memory => @min(8 * @as(u7, next_class_index - class_index), remaining_abi_size),
182913	183408	.x87 => 16,
182914	183409	.float => 4,
182915	183410	.float_combine => 8,
182916		.sseup, .x87up, .none, .win_i128, .integer_per_element => unreachable,
	183411	.sseup,
	183412	.x87up,
	183413	.none,
	183414	.win_i128,
	183415	.integer_per_element,
	183416	.sse_per_element,
	183417	.sse_sse_x87_per_qword,
	183418	.sse_per_xword,
	183419	.sse_per_yword,
	183420	.sse_per_zword,
	183421	=> unreachable,
182917	183422	};
182918	183423	try dst.writeReg(part_disp, switch (class) {
182919	183424	.integer => .u64,
...	...	@@ -182926,7 +183431,18 @@ const Temp = struct {
182926	183431	.x87 => .f80,
182927	183432	.float => .f32,
182928	183433	.float_combine => .vector_2_f32,
182929		.sseup, .x87up, .memory, .none, .win_i128, .integer_per_element => unreachable,
	183434	.sseup,
	183435	.x87up,
	183436	.memory,
	183437	.none,
	183438	.win_i128,
	183439	.integer_per_element,
	183440	.sse_per_element,
	183441	.sse_sse_x87_per_qword,
	183442	.sse_per_xword,
	183443	.sse_per_yword,
	183444	.sse_per_zword,
	183445	=> unreachable,
182930	183446	}, src_reg, cg);
182931	183447	part_disp += part_size;
182932	183448	remaining_abi_size -= part_size;
...	...	@@ -187486,7 +188002,11 @@ const Temp = struct {
187486	188002	.unreach,
187487	188003	.dead,
187488	188004	.indirect_load_frame,
187489		.elementwise_args,
	188005	.elementwise_gpr,
	188006	.elementwise_sse,
	188007	.xwordwise_sse,
	188008	.ywordwise_sse,
	188009	.zwordwise_sse,
187490	188010	.reserved_frame,
187491	188011	.air_ref,
187492	188012	=> unreachable,
...	...	@@ -190152,7 +190672,15 @@ const Select = struct {
190152	190672	.lea_lazy_sym => \|lazy_sym\| .{ .imm = .{ .lazy_sym = lazy_sym } },
190153	190673	.lea_extern_func => \|extern_func\| .{ .imm = .{ .extern_func = extern_func } },
190154	190674	else => \|mcv\| .{ .mem = try mcv.mem(s.cg, .{ .size = op.flags.base.size }) },
190155		.lea_frame, .elementwise_args, .reserved_frame, .air_ref => unreachable,
	190675	.lea_frame,
	190676	.elementwise_gpr,
	190677	.elementwise_sse,
	190678	.xwordwise_sse,
	190679	.ywordwise_sse,
	190680	.zwordwise_sse,
	190681	.reserved_frame,
	190682	.air_ref,
	190683	=> unreachable,
190156	190684	},
190157	190685	1...2 => \|imm\| switch (op.flags.base.ref.valueOf(s)) {
190158	190686	inline .register_pair, .register_triple, .register_quadruple => \|regs\| .{

src/codegen/x86_64/abi.zig+103-103

...	...	@@ -24,59 +24,36 @@ pub const Class = enum {
24	24	float,
25	25	/// A `Class.sse` containing two `f32`s.
26	26	float_combine,
27		/// Clang passes each vector element in a separate `Class.integer`, but returns as `Class.memory`.
	27	/// Clang passes each vector element in a separate `Class.integer`.
28	28	integer_per_element,
29
30		pub const one_integer: [8]Class = .{
31		.integer, .none, .none, .none,
32		.none, .none, .none, .none,
33		};
34		pub const two_integers: [8]Class = .{
35		.integer, .integer, .none, .none,
36		.none, .none, .none, .none,
37		};
38		pub const three_integers: [8]Class = .{
39		.integer, .integer, .integer, .none,
40		.none, .none, .none, .none,
41		};
42		pub const four_integers: [8]Class = .{
43		.integer, .integer, .integer, .integer,
44		.none, .none, .none, .none,
45		};
46		pub const len_integers: [8]Class = .{
47		.integer_per_element, .none, .none, .none,
48		.none, .none, .none, .none,
49		};
	29	/// Clang passes each vector element in a separate `Class.sse`.
	30	sse_per_element,
	31	/// Just complete insanity, idk what to say.
	32	sse_sse_x87_per_qword,
	33	/// Clang passes each 16 bytes in a separate `Class.sse`.
	34	sse_per_xword,
	35	/// Clang passes each 32 bytes in a separate `Class.sse`.
	36	sse_per_yword,
	37	/// Clang passes each 64 bytes in a separate `Class.sse`.
	38	sse_per_zword,
	39
	40	pub const one_integer: [8]Class = .{ .integer, .none, .none, .none, .none, .none, .none, .none };
	41	pub const two_integers: [8]Class = .{ .integer, .integer, .none, .none, .none, .none, .none, .none };
	42	pub const three_integers: [8]Class = .{ .integer, .integer, .integer, .none, .none, .none, .none, .none };
	43	pub const four_integers: [8]Class = .{ .integer, .integer, .integer, .integer, .none, .none, .none, .none };
	44	pub const len_integers: [8]Class = .{ .integer_per_element, .none, .none, .none, .none, .none, .none, .none };
50	45
51	46	pub const @"f16" = @"f64";
52		pub const @"f32": [8]Class = .{
53		.float, .none, .none, .none,
54		.none, .none, .none, .none,
55		};
56		pub const @"f64": [8]Class = .{
57		.sse, .none, .none, .none,
58		.none, .none, .none, .none,
59		};
60		pub const @"f80": [8]Class = .{
61		.x87, .x87up, .none, .none,
62		.none, .none, .none, .none,
63		};
64		pub const @"f128": [8]Class = .{
65		.sse, .sseup, .none, .none,
66		.none, .none, .none, .none,
67		};
	47	pub const @"f32": [8]Class = .{ .float, .none, .none, .none, .none, .none, .none, .none };
	48	pub const @"f64": [8]Class = .{ .sse, .none, .none, .none, .none, .none, .none, .none };
	49	pub const @"f80": [8]Class = .{ .x87, .x87up, .none, .none, .none, .none, .none, .none };
	50	pub const @"f128": [8]Class = .{ .sse, .sseup, .none, .none, .none, .none, .none, .none };
68	51
69	52	/// COMPLEX_X87: This class consists of types that will be returned via the x87
70	53	/// FPU.
71		pub const complex_x87: [8]Class = .{
72		.x87, .x87up, .x87, .x87up,
73		.none, .none, .none, .none,
74		};
	54	pub const complex_x87: [8]Class = .{ .x87, .x87up, .x87, .x87up, .none, .none, .none, .none };
75	55
76		pub const stack: [8]Class = .{
77		.memory, .none, .none, .none,
78		.none, .none, .none, .none,
79		};
	56	pub const stack: [8]Class = .{ .memory, .none, .none, .none, .none, .none, .none, .none };
80	57
81	58	pub fn isX87(class: Class) bool {
82	59	return switch (class) {
...	...	@@ -112,7 +89,7 @@ pub const Class = enum {
112	89
113	90	pub const Context = enum { ret, arg, other };
114	91
115		pub fn classifyWindows(ty: Type, zcu: Zcu, target: const std.Target, ctx: Context) Class {
	92	pub fn classifyWindows(init_ty: Type, zcu: Zcu, target: const std.Target, ctx: Context) Class {
116	93	// https://docs.microsoft.com/en-gb/cpp/build/x64-calling-convention?view=vs-2017
117	94	// "There's a strict one-to-one correspondence between a function call's arguments
118	95	// and the registers used for those arguments. Any argument that doesn't fit in 8
...	...	@@ -121,7 +98,8 @@ pub fn classifyWindows(ty: Type, zcu: Zcu, target: const std.Target, ctx: Cont
121	98	// "All floating point operations are done using the 16 XMM registers."
122	99	// "Structs and unions of size 8, 16, 32, or 64 bits, and __m64 types, are passed
123	100	// as if they were integers of the same size."
124		return switch (ty.zigTypeTag(zcu)) {
	101	var ty = init_ty;
	102	while (true) return switch (ty.zigTypeTag(zcu)) {
125	103	.pointer,
126	104	.int,
127	105	.bool,
...	...	@@ -148,15 +126,41 @@ pub fn classifyWindows(ty: Type, zcu: Zcu, target: const std.Target, ctx: Cont
148	126	else => .memory,
149	127	},
150	128	},
151
152	129	.float => switch (ty.floatBits(target)) {
153	130	16, 32, 64 => .sse,
154	131	80 => .memory,
155	132	128 => if (ctx == .arg) .memory else .sse,
156	133	else => unreachable,
157	134	},
158		.vector => .sse,
159
	135	.vector => {
	136	const len = ty.vectorLen(zcu);
	137	const elem_ty = ty.childType(zcu);
	138	if (len == 1) {
	139	ty = elem_ty;
	140	continue;
	141	}
	142	const reg_size: u64, const split_class: Class = if (target.cpu.has(.x86, .avx512f))
	143	.{ 64, .sse_per_zword }
	144	else if (target.cpu.has(.x86, .avx))
	145	.{ 32, .sse_per_yword }
	146	else
	147	.{ 16, .sse_per_xword };
	148	if (elem_ty.toIntern() == .bool_type) {
	149	if (len > reg_size) return if (ctx == .arg) .integer_per_element else .memory;
	150	return if (ctx == .arg) .memory else .sse;
	151	}
	152	const elem_size = elem_ty.abiSize(zcu);
	153	const unaligned_size = elem_size * len;
	154	if ((unaligned_size <= 8 or unaligned_size > reg_size) and !std.math.isPowerOfTwo(len)) {
	155	if (ctx == .ret and len > Win64.c_abi_int_return_regs.len) return .memory;
	156	if (!elem_ty.isRuntimeFloat()) return .integer_per_element;
	157	if (ctx == .ret and len > 2 and elem_size == 8) return .sse_sse_x87_per_qword;
	158	return .sse_per_element;
	159	}
	160	if (unaligned_size <= reg_size) return if (ctx == .arg) .memory else .sse;
	161	if (ctx == .ret and unaligned_size > reg_size * Win64.c_abi_sse_return_regs.len) return .memory;
	162	return split_class;
	163	},
160	164	.type,
161	165	.comptime_float,
162	166	.comptime_int,
...	...	@@ -206,60 +210,56 @@ pub fn classifySystemV(ty: Type, zcu: Zcu, target: const std.Target, ctx: Cont
206	210	else => unreachable,
207	211	},
208	212	.vector => {
	213	const len = ty.vectorLen(zcu);
	214	if (len == 0) return Class.one_integer;
209	215	const elem_ty = ty.childType(zcu);
210		const bits = elem_ty.bitSize(zcu) * ty.arrayLen(zcu);
211	216	if (elem_ty.toIntern() == .bool_type) {
212		if (bits <= 32) return Class.one_integer;
213		if (bits <= 64) return Class.f64;
214		if (ctx == .other) return Class.stack;
215		if (bits <= 128) return Class.len_integers;
216		if (bits <= 256 and target.cpu.has(.x86, .avx)) return Class.len_integers;
217		if (bits <= 512 and target.cpu.has(.x86, .avx512f)) return Class.len_integers;
	217	if (len <= 32) return Class.one_integer;
	218	if (len <= 64) return Class.f64;
	219	if (ctx != .arg) return Class.stack;
	220	if (len <= 128) return Class.len_integers;
	221	if (len <= 256 and target.cpu.has(.x86, .avx)) return Class.len_integers;
	222	if (len <= 512 and target.cpu.has(.x86, .avx512f)) return Class.len_integers;
218	223	return Class.stack;
219	224	}
220		if (elem_ty.isRuntimeFloat() and elem_ty.floatBits(target) == 80) {
221		if (bits <= 80 * 1) return Class.f80;
222		if (bits <= 80 * 2) return Class.complex_x87;
	225	if (elem_ty.isRuntimeFloat() and elem_ty.floatBits(target) == 80) switch (len) {
	226	0 => unreachable,
	227	1 => return Class.f80,
	228	2 => return Class.complex_x87,
	229	else => return Class.stack,
	230	};
	231	const unaligned_size = elem_ty.abiSize(zcu) * len;
	232	if (unaligned_size <= 4) return Class.one_integer;
	233	if (ctx == .arg and unaligned_size == 8 * 1 * 1 and len == 1 and
	234	elem_ty.isRuntimeFloat()) return Class.stack; // what
	235	if (unaligned_size <= 8 * 1) return .{ .sse, .none, .none, .none, .none, .none, .none, .none };
	236	if (unaligned_size <= 8 * 2) return .{ .sse, .sseup, .none, .none, .none, .none, .none, .none };
	237	if (!target.cpu.has(.x86, .avx)) {
	238	if (ctx == .ret) switch (unaligned_size) {
	239	else => {},
	240	8 * 3 => if (len == 3) return if (elem_ty.isRuntimeFloat()) .{
	241	.sse_sse_x87_per_qword, .none, .none, .none, .none, .none, .none, .none, // how
	242	} else Class.len_integers, // why
	243	8 * 2 * 2, 8 * 2 * 4 => return .{ .sse_per_xword, .none, .none, .none, .none, .none, .none, .none },
	244	};
223	245	return Class.stack;
224	246	}
225		if (bits <= 64 * 1) return .{
226		.sse, .none, .none, .none,
227		.none, .none, .none, .none,
228		};
229		if (bits <= 64 * 2) return .{
230		.sse, .sseup, .none, .none,
231		.none, .none, .none, .none,
232		};
233		if (ctx == .arg and !target.cpu.has(.x86, .avx)) return Class.stack;
234		if (bits <= 64 * 3) return .{
235		.sse, .sseup, .sseup, .none,
236		.none, .none, .none, .none,
237		};
238		if (bits <= 64 * 4) return .{
239		.sse, .sseup, .sseup, .sseup,
240		.none, .none, .none, .none,
241		};
242		if (ctx == .arg and !target.cpu.has(.x86, .avx512f)) return Class.stack;
243		if (bits <= 64 * 5) return .{
244		.sse, .sseup, .sseup, .sseup,
245		.sseup, .none, .none, .none,
246		};
247		if (bits <= 64 * 6) return .{
248		.sse, .sseup, .sseup, .sseup,
249		.sseup, .sseup, .none, .none,
250		};
251		if (bits <= 64 * 7) return .{
252		.sse, .sseup, .sseup, .sseup,
253		.sseup, .sseup, .sseup, .none,
254		};
255		if (bits <= 64 * 8 or (ctx == .ret and bits <= @as(u64, if (target.cpu.has(.x86, .avx512f))
256		64 * 32
257		else if (target.cpu.has(.x86, .avx))
258		64 * 16
259		else
260		64 * 8))) return .{
261		.sse, .sseup, .sseup, .sseup,
262		.sseup, .sseup, .sseup, .sseup,
	247	if (unaligned_size <= 8 * 3) return .{ .sse, .sseup, .sseup, .none, .none, .none, .none, .none };
	248	if (unaligned_size <= 8 * 4) return .{ .sse, .sseup, .sseup, .sseup, .none, .none, .none, .none };
	249	if (!target.cpu.has(.x86, .avx512f)) {
	250	if (ctx == .ret) switch (unaligned_size) {
	251	else => {},
	252	8 * 4 * 2, 8 * 4 * 4 => return .{ .sse_per_yword, .none, .none, .none, .none, .none, .none, .none },
	253	};
	254	return Class.stack;
	255	}
	256	if (unaligned_size <= 8 * 5) return .{ .sse, .sseup, .sseup, .sseup, .sseup, .none, .none, .none };
	257	if (unaligned_size <= 8 * 6) return .{ .sse, .sseup, .sseup, .sseup, .sseup, .sseup, .none, .none };
	258	if (unaligned_size <= 8 * 7) return .{ .sse, .sseup, .sseup, .sseup, .sseup, .sseup, .sseup, .none };
	259	if (unaligned_size <= 8 * 8) return .{ .sse, .sseup, .sseup, .sseup, .sseup, .sseup, .sseup, .sseup };
	260	if (ctx == .ret) switch (unaligned_size) {
	261	else => {},
	262	8 * 8 * 2, 8 * 8 * 4 => return .{ .sse_per_zword, .none, .none, .none, .none, .none, .none, .none },
263	263	};
264	264	return Class.stack;
265	265	},
...	...	@@ -457,7 +457,7 @@ pub const SysV = struct {
457	457	pub const c_abi_int_param_regs = [_]Register{ .rdi, .rsi, .rdx, .rcx, .r8, .r9 };
458	458	pub const c_abi_x87_param_regs = x87_regs[0..0];
459	459	pub const c_abi_sse_param_regs = sse_avx_regs[0..8];
460		pub const c_abi_int_return_regs = [_]Register{ .rax, .rdx };
	460	pub const c_abi_int_return_regs = [_]Register{ .rax, .rdx, .rcx };
461	461	pub const c_abi_x87_return_regs = x87_regs[0..2];
462	462	pub const c_abi_sse_return_regs = sse_avx_regs[0..4];
463	463	};
...	...	@@ -474,9 +474,9 @@ pub const Win64 = struct {
474	474	pub const c_abi_int_param_regs = [_]Register{ .rcx, .rdx, .r8, .r9 };
475	475	pub const c_abi_x87_param_regs = x87_regs[0..0];
476	476	pub const c_abi_sse_param_regs = sse_avx_regs[0..4];
477		pub const c_abi_int_return_regs = [_]Register{.rax};
478		pub const c_abi_x87_return_regs = x87_regs[0..0];
479		pub const c_abi_sse_return_regs = sse_avx_regs[0..1];
	477	pub const c_abi_int_return_regs = [_]Register{ .rax, .rdx, .rcx };
	478	pub const c_abi_x87_return_regs = x87_regs[0..1];
	479	pub const c_abi_sse_return_regs = sse_avx_regs[0..4];
480	480	};
481	481
482	482	pub fn getCalleePreservedRegs(cc: std.lang.CallingConvention.Tag) []const Register {

test/c_abi/cfuncs.c+14163-3984

...	...	@@ -13,7 +13,15 @@ static void assert_or_panic(bool ok) {
13	13	}
14	14	}
15	15
16		#if defined __powerpc__ && !defined _ARCH_PPC64
	16	#if defined(__mips64__)
	17	# define ZIG_MIPS64
	18	#elif defined(__mips__)
	19	# define ZIG_MIPS32
	20	#endif
	21
	22	#if defined(_ARCH_PPC64)
	23	# define ZIG_PPC64
	24	#elif defined(__powerpc__)
17	25	# define ZIG_PPC32
18	26	#endif
19	27
...	...	@@ -211,437 +219,238 @@ float complex zig_cmultf(float complex a, float complex b);
211	219	double complex zig_cmultd(double complex a, double complex b);
212	220	#endif
213	221
214		struct Struct_u8 {
215		uint8_t a;
216		};
217
218		struct Struct_u8 zig_ret_struct_u8(void);
	222	#if defined(ZIG_BACKEND_STAGE2_X86_64) \|\| defined(ZIG_PPC32) \|\| defined(__wasm__)
219	223
220		void zig_struct_u8(struct Struct_u8, size_t);
	224	typedef bool Vector_2_bool __attribute__((ext_vector_type(2)));
221	225
222		struct Struct_u8 c_ret_struct_u8(void) {
223		return (struct Struct_u8){ .a = 4 };
224		}
	226	Vector_2_bool zig_ret_vector_2_bool(void);
	227	void zig_vector_2_bool(Vector_2_bool vec);
225	228
226		void c_struct_u8(struct Struct_u8 s, size_t i) {
227		assert_or_panic(s.a == 5);
228		assert_or_panic(i == 6);
	229	Vector_2_bool c_ret_vector_2_bool(void) {
	230	return (Vector_2_bool){
	231	true,
	232	false,
	233	};
229	234	}
230
231		struct Struct_u16 {
232		uint16_t a;
233		};
234
235		struct Struct_u16 zig_ret_struct_u16(void);
236
237		void zig_struct_u16(struct Struct_u16, size_t);
238
239		struct Struct_u16 c_ret_struct_u16(void) {
240		return (struct Struct_u16){ .a = 10 };
	235	void c_vector_2_bool(Vector_2_bool vec) {
	236	assert_or_panic(vec[0] == true);
	237	assert_or_panic(vec[1] == true);
241	238	}
242
243		void c_struct_u16(struct Struct_u16 s, size_t i) {
244		assert_or_panic(s.a == 11);
245		assert_or_panic(i == 12);
	239	void c_test_vector_2_bool(void) {
	240	Vector_2_bool vec = zig_ret_vector_2_bool();
	241	assert_or_panic(vec[0] == false);
	242	assert_or_panic(vec[1] == false);
	243	zig_vector_2_bool((Vector_2_bool){
	244	false,
	245	true,
	246	});
246	247	}
247	248
248		struct Struct_u32 {
249		uint32_t a;
250		};
251
252		struct Struct_u32 zig_ret_struct_u32(void);
253
254		void zig_struct_u32(struct Struct_u32, size_t);
	249	typedef bool Vector_4_bool __attribute__((ext_vector_type(4)));
255	250
256		struct Struct_u32 c_ret_struct_u32(void) {
257		return (struct Struct_u32){ .a = 16 };
258		}
	251	Vector_4_bool zig_ret_vector_4_bool(void);
	252	void zig_vector_4_bool(Vector_4_bool vec);
259	253
260		void c_struct_u32(struct Struct_u32 s, size_t i) {
261		assert_or_panic(s.a == 17);
262		assert_or_panic(i == 18);
	254	Vector_4_bool c_ret_vector_4_bool(void) {
	255	return (Vector_4_bool){
	256	true,
	257	false,
	258	true,
	259	false,
	260	};
263	261	}
264
265		struct Struct_u64 {
266		uint64_t a;
267		};
268
269		struct Struct_u64 zig_ret_struct_u64(void);
270
271		void zig_struct_u64(struct Struct_u64, size_t);
272
273		struct Struct_u64 c_ret_struct_u64(void) {
274		return (struct Struct_u64){ .a = 22 };
	262	void c_vector_4_bool(Vector_4_bool vec) {
	263	assert_or_panic(vec[0] == true);
	264	assert_or_panic(vec[1] == true);
	265	assert_or_panic(vec[2] == false);
	266	assert_or_panic(vec[3] == true);
275	267	}
276
277		void c_struct_u64(struct Struct_u64 s, size_t i) {
278		assert_or_panic(s.a == 23);
279		assert_or_panic(i == 24);
	268	void c_test_vector_4_bool(void) {
	269	Vector_4_bool vec = zig_ret_vector_4_bool();
	270	assert_or_panic(vec[0] == false);
	271	assert_or_panic(vec[1] == true);
	272	assert_or_panic(vec[2] == true);
	273	assert_or_panic(vec[3] == true);
	274	zig_vector_4_bool((Vector_4_bool){
	275	false,
	276	false,
	277	false,
	278	false,
	279	});
280	280	}
281	281
282		struct Struct_u64_u64 {
283		uint64_t a;
284		uint64_t b;
285		};
286
287		struct Struct_u64_u64 zig_ret_struct_u64_u64(void);
288
289		void zig_struct_u64_u64_0(struct Struct_u64_u64, size_t);
290		void zig_struct_u64_u64_1(size_t, struct Struct_u64_u64, size_t);
291		void zig_struct_u64_u64_2(size_t, size_t, struct Struct_u64_u64, size_t);
292		void zig_struct_u64_u64_3(size_t, size_t, size_t, struct Struct_u64_u64, size_t);
293		void zig_struct_u64_u64_4(size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
294		void zig_struct_u64_u64_5(size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
295		void zig_struct_u64_u64_6(size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
296		void zig_struct_u64_u64_7(size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
297		void zig_struct_u64_u64_8(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
	282	typedef bool Vector_8_bool __attribute__((ext_vector_type(8)));
298	283
299		struct Struct_u64_u64 c_ret_struct_u64_u64(void) {
300		return (struct Struct_u64_u64){ .a = 21, .b = 22 };
301		}
	284	Vector_8_bool zig_ret_vector_8_bool(void);
	285	void zig_vector_8_bool(Vector_8_bool vec);
302	286
303		void c_struct_u64_u64_0(struct Struct_u64_u64 s, size_t i) {
304		assert_or_panic(s.a == 23);
305		assert_or_panic(s.b == 24);
306		assert_or_panic(i == 1);
307		}
308		void c_struct_u64_u64_1(size_t a0, struct Struct_u64_u64 s, size_t i) {
309		assert_or_panic(s.a == 25);
310		assert_or_panic(s.b == 26);
311		assert_or_panic(i == 2);
312		}
313		void c_struct_u64_u64_2(size_t, size_t, struct Struct_u64_u64 s, size_t i) {
314		assert_or_panic(s.a == 27);
315		assert_or_panic(s.b == 28);
316		assert_or_panic(i == 3);
317		}
318		void c_struct_u64_u64_3(size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) {
319		assert_or_panic(s.a == 29);
320		assert_or_panic(s.b == 30);
321		assert_or_panic(i == 4);
322		}
323		void c_struct_u64_u64_4(size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) {
324		assert_or_panic(s.a == 31);
325		assert_or_panic(s.b == 32);
326		assert_or_panic(i == 5);
327		}
328		void c_struct_u64_u64_5(size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) {
329		assert_or_panic(s.a == 33);
330		assert_or_panic(s.b == 34);
331		assert_or_panic(i == 6);
332		}
333		void c_struct_u64_u64_6(size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) {
334		assert_or_panic(s.a == 35);
335		assert_or_panic(s.b == 36);
336		assert_or_panic(i == 7);
	287	Vector_8_bool c_ret_vector_8_bool(void) {
	288	return (Vector_8_bool){
	289	false,
	290	true,
	291	false,
	292	false,
	293	true,
	294	false,
	295	false,
	296	true,
	297	};
337	298	}
338		void c_struct_u64_u64_7(size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) {
339		assert_or_panic(s.a == 37);
340		assert_or_panic(s.b == 38);
341		assert_or_panic(i == 8);
	299	void c_vector_8_bool(Vector_8_bool vec) {
	300	assert_or_panic(vec[0] == true);
	301	assert_or_panic(vec[1] == false);
	302	assert_or_panic(vec[2] == true);
	303	assert_or_panic(vec[3] == true);
	304	assert_or_panic(vec[4] == true);
	305	assert_or_panic(vec[5] == true);
	306	assert_or_panic(vec[6] == false);
	307	assert_or_panic(vec[7] == true);
342	308	}
343		void c_struct_u64_u64_8(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) {
344		assert_or_panic(s.a == 39);
345		assert_or_panic(s.b == 40);
346		assert_or_panic(i == 9);
	309	void c_test_vector_8_bool(void) {
	310	Vector_8_bool vec = zig_ret_vector_8_bool();
	311	assert_or_panic(vec[0] == false);
	312	assert_or_panic(vec[1] == false);
	313	assert_or_panic(vec[2] == false);
	314	assert_or_panic(vec[3] == false);
	315	assert_or_panic(vec[4] == true);
	316	assert_or_panic(vec[5] == false);
	317	assert_or_panic(vec[6] == false);
	318	assert_or_panic(vec[7] == false);
	319	zig_vector_8_bool((Vector_8_bool){
	320	true,
	321	true,
	322	false,
	323	true,
	324	false,
	325	true,
	326	true,
	327	false,
	328	});
347	329	}
348	330
349		struct Struct_f32 {
350		float a;
351		};
352
353		struct Struct_f32 zig_ret_struct_f32(void);
354
355		void zig_struct_f32(struct Struct_f32);
	331	typedef bool Vector_16_bool __attribute__((ext_vector_type(16)));
356	332
357		struct Struct_f32 c_ret_struct_f32(void) {
358		return (struct Struct_f32){ .a = 2.5f };
359		}
	333	Vector_16_bool zig_ret_vector_16_bool(void);
	334	void zig_vector_16_bool(Vector_16_bool vec);
360	335
361		void c_struct_f32(struct Struct_f32 s) {
362		assert_or_panic(s.a == 2.5f);
	336	Vector_16_bool c_ret_vector_16_bool(void) {
	337	return (Vector_16_bool){
	338	true,
	339	true,
	340	false,
	341	false,
	342	false,
	343	false,
	344	true,
	345	false,
	346	true,
	347	false,
	348	false,
	349	true,
	350	true,
	351	false,
	352	true,
	353	true,
	354	};
363	355	}
364
365		struct Struct_f64 {
366		double a;
367		};
368
369		struct Struct_f64 zig_ret_struct_f64(void);
370
371		void zig_struct_f64(struct Struct_f64);
372
373		struct Struct_f64 c_ret_struct_f64(void) {
374		return (struct Struct_f64){ .a = 2.5 };
	356	void c_vector_16_bool(Vector_16_bool vec) {
	357	assert_or_panic(vec[0] == true);
	358	assert_or_panic(vec[1] == false);
	359	assert_or_panic(vec[2] == false);
	360	assert_or_panic(vec[3] == false);
	361	assert_or_panic(vec[4] == true);
	362	assert_or_panic(vec[5] == false);
	363	assert_or_panic(vec[6] == true);
	364	assert_or_panic(vec[7] == true);
	365	assert_or_panic(vec[8] == true);
	366	assert_or_panic(vec[9] == true);
	367	assert_or_panic(vec[10] == true);
	368	assert_or_panic(vec[11] == true);
	369	assert_or_panic(vec[12] == false);
	370	assert_or_panic(vec[13] == false);
	371	assert_or_panic(vec[14] == false);
	372	assert_or_panic(vec[15] == false);
375	373	}
376
377		void c_struct_f64(struct Struct_f64 s) {
378		assert_or_panic(s.a == 2.5);
	374	void c_test_vector_16_bool(void) {
	375	Vector_16_bool vec = zig_ret_vector_16_bool();
	376	assert_or_panic(vec[0] == false);
	377	assert_or_panic(vec[1] == true);
	378	assert_or_panic(vec[2] == false);
	379	assert_or_panic(vec[3] == false);
	380	assert_or_panic(vec[4] == false);
	381	assert_or_panic(vec[5] == true);
	382	assert_or_panic(vec[6] == false);
	383	assert_or_panic(vec[7] == false);
	384	assert_or_panic(vec[8] == true);
	385	assert_or_panic(vec[9] == false);
	386	assert_or_panic(vec[10] == false);
	387	assert_or_panic(vec[11] == false);
	388	assert_or_panic(vec[12] == false);
	389	assert_or_panic(vec[13] == true);
	390	assert_or_panic(vec[14] == false);
	391	assert_or_panic(vec[15] == false);
	392	zig_vector_16_bool((Vector_16_bool){
	393	true,
	394	false,
	395	true,
	396	true,
	397	true,
	398	false,
	399	false,
	400	false,
	401	true,
	402	true,
	403	true,
	404	true,
	405	false,
	406	false,
	407	false,
	408	true,
	409	});
379	410	}
380	411
381		struct Struct_f32a8 {
382		alignas(8) float a;
383		};
384
385		struct Struct_f32a8 zig_ret_struct_f32a8(void);
386
387		void zig_struct_f32a8(struct Struct_f32a8, float);
388
389		struct Struct_f32a8 c_ret_struct_f32a8(void) {
390		return (struct Struct_f32a8){ .a = 4.125f };
391		}
	412	typedef bool Vector_32_bool __attribute__((ext_vector_type(32)));
392	413
393		void c_struct_f32a8(struct Struct_f32a8 s, float f) {
394		assert_or_panic(s.a == 5.375f);
395		assert_or_panic(f == 6.5f);
396		}
	414	Vector_32_bool zig_ret_vector_32_bool(void);
	415	void zig_vector_32_bool(Vector_32_bool vec);
397	416
398		struct Struct_f32a8_f32a8 {
399		alignas(8) float a;
400		alignas(8) float b;
401		};
402
403		struct Struct_f32a8_f32a8 zig_ret_struct_f32a8_f32a8(void);
404
405		void zig_struct_f32a8_f32a8(struct Struct_f32a8_f32a8, float);
406
407		struct Struct_f32a8_f32a8 c_ret_struct_f32a8_f32a8(void) {
408		return (struct Struct_f32a8_f32a8){ .a = 6.625f, .b = 7.875f };
409		}
410
411		void c_struct_f32a8_f32a8(struct Struct_f32a8_f32a8 s, float f) {
412		assert_or_panic(s.a == 8.0625f);
413		assert_or_panic(s.b == 9.1875f);
414		assert_or_panic(f == 10.5f);
415		}
416
417		struct Struct_f32f32_f32 {
418		struct {
419		float b, c;
420		} a;
421		float d;
422		};
423
424		struct Struct_f32f32_f32 zig_ret_struct_f32f32_f32(void);
425
426		void zig_struct_f32f32_f32(struct Struct_f32f32_f32);
427
428		struct Struct_f32f32_f32 c_ret_struct_f32f32_f32(void) {
429		return (struct Struct_f32f32_f32){ .a = { .b = 1.0f, .c = 2.0f }, .d = 3.0f };
430		}
431
432		void c_struct_f32f32_f32(struct Struct_f32f32_f32 s) {
433		assert_or_panic(s.a.b == 1.0f);
434		assert_or_panic(s.a.c == 2.0f);
435		assert_or_panic(s.d == 3.0f);
436		}
437
438		struct Struct_f32_f32f32 {
439		float a;
440		struct {
441		float c, d;
442		} b;
443		};
444
445		struct Struct_f32_f32f32 zig_ret_struct_f32_f32f32(void);
446
447		void zig_struct_f32_f32f32(struct Struct_f32_f32f32);
448
449		struct Struct_f32_f32f32 c_ret_struct_f32_f32f32(void) {
450		return (struct Struct_f32_f32f32){ .a = 1.0f, .b = { .c = 2.0f, .d = 3.0f } };
451		}
452
453		void c_struct_f32_f32f32(struct Struct_f32_f32f32 s) {
454		assert_or_panic(s.a == 1.0f);
455		assert_or_panic(s.b.c == 2.0f);
456		assert_or_panic(s.b.d == 3.0f);
457		}
458
459		struct Struct_u32_Union_u32_u32u32 {
460		uint32_t a;
461		union {
462		struct {
463		uint32_t d, e;
464		} c;
465		} b;
466		};
467
468		struct Struct_u32_Union_u32_u32u32 zig_ret_struct_u32_union_u32_u32u32(void);
469
470		void zig_struct_u32_union_u32_u32u32(struct Struct_u32_Union_u32_u32u32);
471
472		struct Struct_u32_Union_u32_u32u32 c_ret_struct_u32_union_u32_u32u32(void) {
473		struct Struct_u32_Union_u32_u32u32 s;
474		s.a = 1;
475		s.b.c.d = 2;
476		s.b.c.e = 3;
477		return s;
478		}
479
480		void c_struct_u32_union_u32_u32u32(struct Struct_u32_Union_u32_u32u32 s) {
481		assert_or_panic(s.a == 1);
482		assert_or_panic(s.b.c.d == 2);
483		assert_or_panic(s.b.c.e == 3);
484		}
485
486		struct Struct_i32_i32 {
487		int32_t a;
488		int32_t b;
489		};
490
491		void zig_struct_i32_i32(struct Struct_i32_i32);
492
493		struct BigStruct {
494		uint64_t a;
495		uint64_t b;
496		uint64_t c;
497		uint64_t d;
498		uint8_t e;
499		};
500
501		void zig_big_struct(struct BigStruct);
502
503		union BigUnion {
504		struct BigStruct a;
505		};
506
507		void zig_big_union(union BigUnion);
508
509		struct SmallStructInts {
510		uint8_t a;
511		uint8_t b;
512		uint8_t c;
513		uint8_t d;
514		};
515
516		void zig_small_struct_ints(struct SmallStructInts);
517		struct SmallStructInts zig_ret_small_struct_ints();
518
519		struct MedStructInts {
520		int32_t x;
521		int32_t y;
522		int32_t z;
523		};
524
525		void zig_med_struct_ints(struct MedStructInts);
526		struct MedStructInts zig_ret_med_struct_ints();
527
528		struct MedStructMixed {
529		uint32_t a;
530		float b;
531		float c;
532		uint32_t d;
533		};
534
535		void zig_med_struct_mixed(struct MedStructMixed);
536		struct MedStructMixed zig_ret_med_struct_mixed();
537
538		void zig_small_packed_struct(uint8_t);
539		#ifndef ZIG_NO_I128
540		void zig_big_packed_struct(__int128);
541		#endif
542
543		struct SplitStructInts {
544		uint64_t a;
545		uint8_t b;
546		uint32_t c;
547		};
548		void zig_split_struct_ints(struct SplitStructInts);
549
550		struct SplitStructMixed {
551		uint64_t a;
552		uint8_t b;
553		float c;
554		};
555		void zig_split_struct_mixed(struct SplitStructMixed);
556		struct SplitStructMixed zig_ret_split_struct_mixed();
557
558		struct BigStruct zig_big_struct_both(struct BigStruct);
559
560		typedef float Vector2Float __attribute__((ext_vector_type(2)));
561		typedef float Vector4Float __attribute__((ext_vector_type(4)));
562
563		void c_vector_2_float(Vector2Float vec) {
564		assert_or_panic(vec[0] == 1.0);
565		assert_or_panic(vec[1] == 2.0);
566		}
567
568		void c_vector_4_float(Vector4Float vec) {
569		assert_or_panic(vec[0] == 1.0);
570		assert_or_panic(vec[1] == 2.0);
571		assert_or_panic(vec[2] == 3.0);
572		assert_or_panic(vec[3] == 4.0);
573		}
574
575		Vector2Float c_ret_vector_2_float(void) {
576		return (Vector2Float){
577		1.0,
578		2.0,
579		};
580		}
581		Vector4Float c_ret_vector_4_float(void) {
582		return (Vector4Float){
583		1.0,
584		2.0,
585		3.0,
586		4.0,
	417	Vector_32_bool c_ret_vector_32_bool(void) {
	418	return (Vector_32_bool){
	419	true,
	420	false,
	421	true,
	422	true,
	423	true,
	424	false,
	425	true,
	426	false,
	427	true,
	428	true,
	429	true,
	430	false,
	431	true,
	432	true,
	433	false,
	434	false,
	435	true,
	436	false,
	437	false,
	438	false,
	439	false,
	440	true,
	441	true,
	442	true,
	443	false,
	444	true,
	445	false,
	446	false,
	447	true,
	448	false,
	449	false,
	450	false,
587	451	};
588	452	}
589
590		#if defined(ZIG_BACKEND_STAGE2_X86_64) \|\| defined(ZIG_PPC32) \|\| defined(__wasm__)
591
592		typedef bool Vector2Bool __attribute__((ext_vector_type(2)));
593		typedef bool Vector4Bool __attribute__((ext_vector_type(4)));
594		typedef bool Vector8Bool __attribute__((ext_vector_type(8)));
595		typedef bool Vector16Bool __attribute__((ext_vector_type(16)));
596		typedef bool Vector32Bool __attribute__((ext_vector_type(32)));
597		typedef bool Vector64Bool __attribute__((ext_vector_type(64)));
598		typedef bool Vector128Bool __attribute__((ext_vector_type(128)));
599		typedef bool Vector256Bool __attribute__((ext_vector_type(256)));
600		typedef bool Vector512Bool __attribute__((ext_vector_type(512)));
601
602		void c_vector_2_bool(Vector2Bool vec) {
603		assert_or_panic(vec[0] == true);
604		assert_or_panic(vec[1] == true);
605		}
606
607		void c_vector_4_bool(Vector4Bool vec) {
608		assert_or_panic(vec[0] == true);
609		assert_or_panic(vec[1] == true);
610		assert_or_panic(vec[2] == false);
611		assert_or_panic(vec[3] == true);
612		}
613
614		void c_vector_8_bool(Vector8Bool vec) {
615		assert_or_panic(vec[0] == true);
616		assert_or_panic(vec[1] == false);
617		assert_or_panic(vec[2] == true);
618		assert_or_panic(vec[3] == true);
619		assert_or_panic(vec[4] == true);
620		assert_or_panic(vec[5] == true);
621		assert_or_panic(vec[6] == false);
622		assert_or_panic(vec[7] == true);
623		}
624
625		void c_vector_16_bool(Vector16Bool vec) {
626		assert_or_panic(vec[0] == true);
627		assert_or_panic(vec[1] == false);
628		assert_or_panic(vec[2] == false);
629		assert_or_panic(vec[3] == false);
630		assert_or_panic(vec[4] == true);
631		assert_or_panic(vec[5] == false);
632		assert_or_panic(vec[6] == true);
633		assert_or_panic(vec[7] == true);
634		assert_or_panic(vec[8] == true);
635		assert_or_panic(vec[9] == true);
636		assert_or_panic(vec[10] == true);
637		assert_or_panic(vec[11] == true);
638		assert_or_panic(vec[12] == false);
639		assert_or_panic(vec[13] == false);
640		assert_or_panic(vec[14] == false);
641		assert_or_panic(vec[15] == false);
642		}
643
644		void c_vector_32_bool(Vector32Bool vec) {
	453	void c_vector_32_bool(Vector_32_bool vec) {
645	454	assert_or_panic(vec[0] == true);
646	455	assert_or_panic(vec[1] == false);
647	456	assert_or_panic(vec[2] == true);
...	...	@@ -675,29 +484,171 @@ void c_vector_32_bool(Vector32Bool vec) {
675	484	assert_or_panic(vec[30] == true);
676	485	assert_or_panic(vec[31] == false);
677	486	}
678
679		void c_vector_64_bool(Vector64Bool vec) {
680		assert_or_panic(vec[0] == true);
	487	void c_test_vector_32_bool(void) {
	488	Vector_32_bool vec = zig_ret_vector_32_bool();
	489	assert_or_panic(vec[0] == false);
681	490	assert_or_panic(vec[1] == true);
682		assert_or_panic(vec[2] == true);
	491	assert_or_panic(vec[2] == false);
683	492	assert_or_panic(vec[3] == false);
684	493	assert_or_panic(vec[4] == true);
685	494	assert_or_panic(vec[5] == false);
686		assert_or_panic(vec[6] == false);
687		assert_or_panic(vec[7] == false);
	495	assert_or_panic(vec[6] == true);
	496	assert_or_panic(vec[7] == true);
688	497	assert_or_panic(vec[8] == true);
689		assert_or_panic(vec[9] == false);
690		assert_or_panic(vec[10] == false);
691		assert_or_panic(vec[11] == false);
	498	assert_or_panic(vec[9] == true);
	499	assert_or_panic(vec[10] == true);
	500	assert_or_panic(vec[11] == true);
692	501	assert_or_panic(vec[12] == false);
693		assert_or_panic(vec[13] == true);
694		assert_or_panic(vec[14] == true);
695		assert_or_panic(vec[15] == true);
696		assert_or_panic(vec[16] == true);
	502	assert_or_panic(vec[13] == false);
	503	assert_or_panic(vec[14] == false);
	504	assert_or_panic(vec[15] == false);
	505	assert_or_panic(vec[16] == false);
697	506	assert_or_panic(vec[17] == false);
698		assert_or_panic(vec[18] == false);
	507	assert_or_panic(vec[18] == true);
699	508	assert_or_panic(vec[19] == true);
700		assert_or_panic(vec[20] == false);
	509	assert_or_panic(vec[20] == true);
	510	assert_or_panic(vec[21] == false);
	511	assert_or_panic(vec[22] == true);
	512	assert_or_panic(vec[23] == false);
	513	assert_or_panic(vec[24] == true);
	514	assert_or_panic(vec[25] == false);
	515	assert_or_panic(vec[26] == false);
	516	assert_or_panic(vec[27] == true);
	517	assert_or_panic(vec[28] == false);
	518	assert_or_panic(vec[29] == false);
	519	assert_or_panic(vec[30] == true);
	520	assert_or_panic(vec[31] == true);
	521	zig_vector_32_bool((Vector_32_bool){
	522	false,
	523	false,
	524	false,
	525	true,
	526	true,
	527	false,
	528	false,
	529	true,
	530	false,
	531	true,
	532	true,
	533	true,
	534	false,
	535	false,
	536	true,
	537	true,
	538	true,
	539	true,
	540	true,
	541	false,
	542	true,
	543	true,
	544	true,
	545	false,
	546	false,
	547	true,
	548	true,
	549	false,
	550	true,
	551	true,
	552	false,
	553	true,
	554	});
	555	}
	556
	557	typedef bool Vector_64_bool __attribute__((ext_vector_type(64)));
	558
	559	Vector_64_bool zig_ret_vector_64_bool(void);
	560	void zig_vector_64_bool(Vector_64_bool vec);
	561
	562	Vector_64_bool c_ret_vector_64_bool(void) {
	563	return (Vector_64_bool){
	564	false,
	565	true,
	566	false,
	567	true,
	568	true,
	569	true,
	570	false,
	571	true,
	572	true,
	573	true,
	574	true,
	575	true,
	576	true,
	577	false,
	578	true,
	579	true,
	580	true,
	581	false,
	582	false,
	583	false,
	584	true,
	585	true,
	586	false,
	587	true,
	588	false,
	589	true,
	590	false,
	591	true,
	592	false,
	593	true,
	594	false,
	595	true,
	596	false,
	597	false,
	598	true,
	599	true,
	600	false,
	601	false,
	602	false,
	603	true,
	604	true,
	605	true,
	606	true,
	607	false,
	608	false,
	609	false,
	610	true,
	611	true,
	612	false,
	613	false,
	614	true,
	615	false,
	616	false,
	617	false,
	618	false,
	619	true,
	620	false,
	621	false,
	622	false,
	623	true,
	624	true,
	625	true,
	626	true,
	627	true,
	628	};
	629	}
	630	void c_vector_64_bool(Vector_64_bool vec) {
	631	assert_or_panic(vec[0] == true);
	632	assert_or_panic(vec[1] == true);
	633	assert_or_panic(vec[2] == true);
	634	assert_or_panic(vec[3] == false);
	635	assert_or_panic(vec[4] == true);
	636	assert_or_panic(vec[5] == false);
	637	assert_or_panic(vec[6] == false);
	638	assert_or_panic(vec[7] == false);
	639	assert_or_panic(vec[8] == true);
	640	assert_or_panic(vec[9] == false);
	641	assert_or_panic(vec[10] == false);
	642	assert_or_panic(vec[11] == false);
	643	assert_or_panic(vec[12] == false);
	644	assert_or_panic(vec[13] == true);
	645	assert_or_panic(vec[14] == true);
	646	assert_or_panic(vec[15] == true);
	647	assert_or_panic(vec[16] == true);
	648	assert_or_panic(vec[17] == false);
	649	assert_or_panic(vec[18] == false);
	650	assert_or_panic(vec[19] == true);
	651	assert_or_panic(vec[20] == false);
701	652	assert_or_panic(vec[21] == true);
702	653	assert_or_panic(vec[22] == false);
703	654	assert_or_panic(vec[23] == true);
...	...	@@ -742,430 +693,438 @@ void c_vector_64_bool(Vector64Bool vec) {
742	693	assert_or_panic(vec[62] == true);
743	694	assert_or_panic(vec[63] == false);
744	695	}
745
746		void c_vector_128_bool(Vector128Bool vec) {
747		assert_or_panic(vec[0] == false);
	696	void c_test_vector_64_bool(void) {
	697	Vector_64_bool vec = zig_ret_vector_64_bool();
	698	assert_or_panic(vec[0] == true);
748	699	assert_or_panic(vec[1] == false);
749		assert_or_panic(vec[2] == false);
	700	assert_or_panic(vec[2] == true);
750	701	assert_or_panic(vec[3] == false);
751	702	assert_or_panic(vec[4] == false);
752	703	assert_or_panic(vec[5] == true);
753		assert_or_panic(vec[6] == true);
754		assert_or_panic(vec[7] == false);
	704	assert_or_panic(vec[6] == false);
	705	assert_or_panic(vec[7] == true);
755	706	assert_or_panic(vec[8] == true);
756		assert_or_panic(vec[9] == true);
757		assert_or_panic(vec[10] == false);
758		assert_or_panic(vec[11] == true);
	707	assert_or_panic(vec[9] == false);
	708	assert_or_panic(vec[10] == true);
	709	assert_or_panic(vec[11] == false);
759	710	assert_or_panic(vec[12] == true);
760	711	assert_or_panic(vec[13] == false);
761		assert_or_panic(vec[14] == true);
	712	assert_or_panic(vec[14] == false);
762	713	assert_or_panic(vec[15] == true);
763		assert_or_panic(vec[16] == true);
	714	assert_or_panic(vec[16] == false);
764	715	assert_or_panic(vec[17] == false);
765		assert_or_panic(vec[18] == false);
766		assert_or_panic(vec[19] == false);
	716	assert_or_panic(vec[18] == true);
	717	assert_or_panic(vec[19] == true);
767	718	assert_or_panic(vec[20] == false);
768		assert_or_panic(vec[21] == true);
	719	assert_or_panic(vec[21] == false);
769	720	assert_or_panic(vec[22] == true);
770	721	assert_or_panic(vec[23] == false);
771	722	assert_or_panic(vec[24] == false);
772		assert_or_panic(vec[25] == false);
	723	assert_or_panic(vec[25] == true);
773	724	assert_or_panic(vec[26] == true);
774	725	assert_or_panic(vec[27] == true);
775		assert_or_panic(vec[28] == false);
	726	assert_or_panic(vec[28] == true);
776	727	assert_or_panic(vec[29] == true);
777	728	assert_or_panic(vec[30] == false);
778	729	assert_or_panic(vec[31] == false);
779	730	assert_or_panic(vec[32] == true);
780		assert_or_panic(vec[33] == false);
781		assert_or_panic(vec[34] == false);
	731	assert_or_panic(vec[33] == true);
	732	assert_or_panic(vec[34] == true);
782	733	assert_or_panic(vec[35] == true);
783		assert_or_panic(vec[36] == true);
	734	assert_or_panic(vec[36] == false);
784	735	assert_or_panic(vec[37] == true);
785		assert_or_panic(vec[38] == true);
	736	assert_or_panic(vec[38] == false);
786	737	assert_or_panic(vec[39] == true);
787		assert_or_panic(vec[40] == false);
	738	assert_or_panic(vec[40] == true);
788	739	assert_or_panic(vec[41] == true);
789	740	assert_or_panic(vec[42] == true);
790	741	assert_or_panic(vec[43] == true);
791	742	assert_or_panic(vec[44] == false);
792	743	assert_or_panic(vec[45] == false);
793	744	assert_or_panic(vec[46] == false);
794		assert_or_panic(vec[47] == false);
	745	assert_or_panic(vec[47] == true);
795	746	assert_or_panic(vec[48] == true);
796	747	assert_or_panic(vec[49] == true);
797	748	assert_or_panic(vec[50] == false);
798	749	assert_or_panic(vec[51] == true);
799	750	assert_or_panic(vec[52] == true);
800	751	assert_or_panic(vec[53] == true);
801		assert_or_panic(vec[54] == true);
802		assert_or_panic(vec[55] == true);
	752	assert_or_panic(vec[54] == false);
	753	assert_or_panic(vec[55] == false);
803	754	assert_or_panic(vec[56] == false);
804	755	assert_or_panic(vec[57] == true);
805		assert_or_panic(vec[58] == true);
	756	assert_or_panic(vec[58] == false);
806	757	assert_or_panic(vec[59] == false);
807	758	assert_or_panic(vec[60] == true);
808	759	assert_or_panic(vec[61] == false);
809		assert_or_panic(vec[62] == false);
810		assert_or_panic(vec[63] == true);
811		assert_or_panic(vec[64] == true);
812		assert_or_panic(vec[65] == false);
813		assert_or_panic(vec[66] == true);
814		assert_or_panic(vec[67] == true);
815		assert_or_panic(vec[68] == false);
816		assert_or_panic(vec[69] == true);
817		assert_or_panic(vec[70] == false);
818		assert_or_panic(vec[71] == false);
819		assert_or_panic(vec[72] == true);
820		assert_or_panic(vec[73] == true);
821		assert_or_panic(vec[74] == false);
822		assert_or_panic(vec[75] == true);
823		assert_or_panic(vec[76] == true);
824		assert_or_panic(vec[77] == true);
825		assert_or_panic(vec[78] == false);
826		assert_or_panic(vec[79] == true);
827		assert_or_panic(vec[80] == false);
828		assert_or_panic(vec[81] == false);
829		assert_or_panic(vec[82] == false);
830		assert_or_panic(vec[83] == false);
831		assert_or_panic(vec[84] == true);
832		assert_or_panic(vec[85] == false);
833		assert_or_panic(vec[86] == false);
834		assert_or_panic(vec[87] == false);
835		assert_or_panic(vec[88] == true);
836		assert_or_panic(vec[89] == true);
837		assert_or_panic(vec[90] == false);
838		assert_or_panic(vec[91] == false);
839		assert_or_panic(vec[92] == true);
840		assert_or_panic(vec[93] == true);
841		assert_or_panic(vec[94] == true);
842		assert_or_panic(vec[95] == true);
843		assert_or_panic(vec[96] == false);
844		assert_or_panic(vec[97] == false);
845		assert_or_panic(vec[98] == false);
846		assert_or_panic(vec[99] == false);
847		assert_or_panic(vec[100] == false);
848		assert_or_panic(vec[101] == true);
849		assert_or_panic(vec[102] == false);
850		assert_or_panic(vec[103] == false);
851		assert_or_panic(vec[104] == false);
852		assert_or_panic(vec[105] == false);
853		assert_or_panic(vec[106] == true);
854		assert_or_panic(vec[107] == true);
855		assert_or_panic(vec[108] == true);
856		assert_or_panic(vec[109] == true);
857		assert_or_panic(vec[110] == true);
858		assert_or_panic(vec[111] == false);
859		assert_or_panic(vec[112] == false);
860		assert_or_panic(vec[113] == true);
861		assert_or_panic(vec[114] == false);
862		assert_or_panic(vec[115] == true);
863		assert_or_panic(vec[116] == false);
864		assert_or_panic(vec[117] == false);
865		assert_or_panic(vec[118] == true);
866		assert_or_panic(vec[119] == false);
867		assert_or_panic(vec[120] == true);
868		assert_or_panic(vec[121] == false);
869		assert_or_panic(vec[122] == true);
870		assert_or_panic(vec[123] == true);
871		assert_or_panic(vec[124] == true);
872		assert_or_panic(vec[125] == true);
873		assert_or_panic(vec[126] == true);
874		assert_or_panic(vec[127] == true);
875		}
876
877		// WASM: The following vector functions define too many Wasm locals for wasmtime in debug mode and are therefore disabled for the wasm target.
878		#if !defined(__wasm__)
879
880		void c_vector_256_bool(Vector256Bool vec) {
881		assert_or_panic(vec[0] == false);
882		assert_or_panic(vec[1] == true);
883		assert_or_panic(vec[2] == true);
884		assert_or_panic(vec[3] == false);
885		assert_or_panic(vec[4] == false);
886		assert_or_panic(vec[5] == true);
887		assert_or_panic(vec[6] == true);
888		assert_or_panic(vec[7] == true);
889		assert_or_panic(vec[8] == false);
	760	assert_or_panic(vec[62] == true);
	761	assert_or_panic(vec[63] == false);
	762	zig_vector_64_bool((Vector_64_bool){
	763	true,
	764	true,
	765	false,
	766	true,
	767	false,
	768	true,
	769	false,
	770	false,
	771	true,
	772	true,
	773	true,
	774	true,
	775	true,
	776	true,
	777	true,
	778	false,
	779	false,
	780	true,
	781	true,
	782	false,
	783	true,
	784	true,
	785	true,
	786	true,
	787	false,
	788	false,
	789	true,
	790	false,
	791	false,
	792	true,
	793	false,
	794	true,
	795	false,
	796	true,
	797	true,
	798	false,
	799	true,
	800	true,
	801	false,
	802	false,
	803	true,
	804	true,
	805	true,
	806	true,
	807	true,
	808	false,
	809	true,
	810	false,
	811	false,
	812	false,
	813	false,
	814	false,
	815	true,
	816	false,
	817	false,
	818	true,
	819	true,
	820	false,
	821	false,
	822	false,
	823	true,
	824	true,
	825	true,
	826	true,
	827	});
	828	}
	829
	830	typedef bool Vector_128_bool __attribute__((ext_vector_type(128)));
	831
	832	Vector_128_bool zig_ret_vector_128_bool(void);
	833	void zig_vector_128_bool(Vector_128_bool vec);
	834
	835	Vector_128_bool c_ret_vector_128_bool(void) {
	836	return (Vector_128_bool){
	837	false,
	838	true,
	839	true,
	840	false,
	841	true,
	842	false,
	843	false,
	844	true,
	845	true,
	846	false,
	847	true,
	848	false,
	849	false,
	850	false,
	851	true,
	852	false,
	853	true,
	854	false,
	855	false,
	856	true,
	857	false,
	858	true,
	859	false,
	860	false,
	861	false,
	862	true,
	863	true,
	864	true,
	865	false,
	866	false,
	867	false,
	868	false,
	869	true,
	870	true,
	871	true,
	872	false,
	873	true,
	874	true,
	875	false,
	876	false,
	877	false,
	878	false,
	879	true,
	880	true,
	881	true,
	882	false,
	883	false,
	884	false,
	885	false,
	886	true,
	887	false,
	888	false,
	889	true,
	890	false,
	891	false,
	892	false,
	893	false,
	894	false,
	895	true,
	896	true,
	897	true,
	898	false,
	899	true,
	900	true,
	901	false,
	902	false,
	903	false,
	904	false,
	905	false,
	906	false,
	907	false,
	908	false,
	909	true,
	910	true,
	911	true,
	912	true,
	913	true,
	914	false,
	915	false,
	916	false,
	917	false,
	918	false,
	919	false,
	920	true,
	921	false,
	922	true,
	923	false,
	924	true,
	925	false,
	926	true,
	927	false,
	928	true,
	929	true,
	930	true,
	931	true,
	932	false,
	933	false,
	934	true,
	935	false,
	936	false,
	937	true,
	938	true,
	939	true,
	940	true,
	941	false,
	942	true,
	943	true,
	944	true,
	945	false,
	946	false,
	947	true,
	948	false,
	949	false,
	950	true,
	951	true,
	952	false,
	953	true,
	954	false,
	955	true,
	956	true,
	957	true,
	958	true,
	959	true,
	960	false,
	961	false,
	962	true,
	963	false,
	964	true,
	965	};
	966	}
	967	void c_vector_128_bool(Vector_128_bool vec) {
	968	assert_or_panic(vec[0] == false);
	969	assert_or_panic(vec[1] == false);
	970	assert_or_panic(vec[2] == false);
	971	assert_or_panic(vec[3] == false);
	972	assert_or_panic(vec[4] == false);
	973	assert_or_panic(vec[5] == true);
	974	assert_or_panic(vec[6] == true);
	975	assert_or_panic(vec[7] == false);
	976	assert_or_panic(vec[8] == true);
890	977	assert_or_panic(vec[9] == true);
891		assert_or_panic(vec[10] == true);
	978	assert_or_panic(vec[10] == false);
892	979	assert_or_panic(vec[11] == true);
893		assert_or_panic(vec[12] == false);
894		assert_or_panic(vec[13] == true);
895		assert_or_panic(vec[14] == false);
	980	assert_or_panic(vec[12] == true);
	981	assert_or_panic(vec[13] == false);
	982	assert_or_panic(vec[14] == true);
896	983	assert_or_panic(vec[15] == true);
897		assert_or_panic(vec[16] == false);
	984	assert_or_panic(vec[16] == true);
898	985	assert_or_panic(vec[17] == false);
899		assert_or_panic(vec[18] == true);
900		assert_or_panic(vec[19] == true);
	986	assert_or_panic(vec[18] == false);
	987	assert_or_panic(vec[19] == false);
901	988	assert_or_panic(vec[20] == false);
902	989	assert_or_panic(vec[21] == true);
903		assert_or_panic(vec[22] == false);
	990	assert_or_panic(vec[22] == true);
904	991	assert_or_panic(vec[23] == false);
905	992	assert_or_panic(vec[24] == false);
906		assert_or_panic(vec[25] == true);
	993	assert_or_panic(vec[25] == false);
907	994	assert_or_panic(vec[26] == true);
908		assert_or_panic(vec[27] == false);
	995	assert_or_panic(vec[27] == true);
909	996	assert_or_panic(vec[28] == false);
910	997	assert_or_panic(vec[29] == true);
911		assert_or_panic(vec[30] == true);
	998	assert_or_panic(vec[30] == false);
912	999	assert_or_panic(vec[31] == false);
913	1000	assert_or_panic(vec[32] == true);
914	1001	assert_or_panic(vec[33] == false);
915	1002	assert_or_panic(vec[34] == false);
916	1003	assert_or_panic(vec[35] == true);
917		assert_or_panic(vec[36] == false);
	1004	assert_or_panic(vec[36] == true);
918	1005	assert_or_panic(vec[37] == true);
919		assert_or_panic(vec[38] == false);
	1006	assert_or_panic(vec[38] == true);
920	1007	assert_or_panic(vec[39] == true);
921		assert_or_panic(vec[40] == true);
	1008	assert_or_panic(vec[40] == false);
922	1009	assert_or_panic(vec[41] == true);
923	1010	assert_or_panic(vec[42] == true);
924		assert_or_panic(vec[43] == false);
	1011	assert_or_panic(vec[43] == true);
925	1012	assert_or_panic(vec[44] == false);
926		assert_or_panic(vec[45] == true);
	1013	assert_or_panic(vec[45] == false);
927	1014	assert_or_panic(vec[46] == false);
928	1015	assert_or_panic(vec[47] == false);
929		assert_or_panic(vec[48] == false);
930		assert_or_panic(vec[49] == false);
	1016	assert_or_panic(vec[48] == true);
	1017	assert_or_panic(vec[49] == true);
931	1018	assert_or_panic(vec[50] == false);
932		assert_or_panic(vec[51] == false);
	1019	assert_or_panic(vec[51] == true);
933	1020	assert_or_panic(vec[52] == true);
934	1021	assert_or_panic(vec[53] == true);
935	1022	assert_or_panic(vec[54] == true);
936	1023	assert_or_panic(vec[55] == true);
937		assert_or_panic(vec[56] == true);
	1024	assert_or_panic(vec[56] == false);
938	1025	assert_or_panic(vec[57] == true);
939		assert_or_panic(vec[58] == false);
940		assert_or_panic(vec[59] == true);
	1026	assert_or_panic(vec[58] == true);
	1027	assert_or_panic(vec[59] == false);
941	1028	assert_or_panic(vec[60] == true);
942	1029	assert_or_panic(vec[61] == false);
943	1030	assert_or_panic(vec[62] == false);
944	1031	assert_or_panic(vec[63] == true);
945		assert_or_panic(vec[64] == false);
	1032	assert_or_panic(vec[64] == true);
946	1033	assert_or_panic(vec[65] == false);
947		assert_or_panic(vec[66] == false);
948		assert_or_panic(vec[67] == false);
	1034	assert_or_panic(vec[66] == true);
	1035	assert_or_panic(vec[67] == true);
949	1036	assert_or_panic(vec[68] == false);
950		assert_or_panic(vec[69] == false);
951		assert_or_panic(vec[70] == true);
952		assert_or_panic(vec[71] == true);
	1037	assert_or_panic(vec[69] == true);
	1038	assert_or_panic(vec[70] == false);
	1039	assert_or_panic(vec[71] == false);
953	1040	assert_or_panic(vec[72] == true);
954		assert_or_panic(vec[73] == false);
	1041	assert_or_panic(vec[73] == true);
955	1042	assert_or_panic(vec[74] == false);
956		assert_or_panic(vec[75] == false);
	1043	assert_or_panic(vec[75] == true);
957	1044	assert_or_panic(vec[76] == true);
958		assert_or_panic(vec[77] == false);
959		assert_or_panic(vec[78] == true);
	1045	assert_or_panic(vec[77] == true);
	1046	assert_or_panic(vec[78] == false);
960	1047	assert_or_panic(vec[79] == true);
961	1048	assert_or_panic(vec[80] == false);
962	1049	assert_or_panic(vec[81] == false);
963		assert_or_panic(vec[82] == true);
964		assert_or_panic(vec[83] == true);
965		assert_or_panic(vec[84] == false);
966		assert_or_panic(vec[85] == true);
967		assert_or_panic(vec[86] == true);
968		assert_or_panic(vec[87] == true);
	1050	assert_or_panic(vec[82] == false);
	1051	assert_or_panic(vec[83] == false);
	1052	assert_or_panic(vec[84] == true);
	1053	assert_or_panic(vec[85] == false);
	1054	assert_or_panic(vec[86] == false);
	1055	assert_or_panic(vec[87] == false);
969	1056	assert_or_panic(vec[88] == true);
970	1057	assert_or_panic(vec[89] == true);
971		assert_or_panic(vec[90] == true);
972		assert_or_panic(vec[91] == true);
973		assert_or_panic(vec[92] == false);
	1058	assert_or_panic(vec[90] == false);
	1059	assert_or_panic(vec[91] == false);
	1060	assert_or_panic(vec[92] == true);
974	1061	assert_or_panic(vec[93] == true);
975	1062	assert_or_panic(vec[94] == true);
976		assert_or_panic(vec[95] == false);
	1063	assert_or_panic(vec[95] == true);
977	1064	assert_or_panic(vec[96] == false);
978		assert_or_panic(vec[97] == true);
979		assert_or_panic(vec[98] == true);
	1065	assert_or_panic(vec[97] == false);
	1066	assert_or_panic(vec[98] == false);
980	1067	assert_or_panic(vec[99] == false);
981		assert_or_panic(vec[100] == true);
982		assert_or_panic(vec[101] == false);
	1068	assert_or_panic(vec[100] == false);
	1069	assert_or_panic(vec[101] == true);
983	1070	assert_or_panic(vec[102] == false);
984		assert_or_panic(vec[103] == true);
	1071	assert_or_panic(vec[103] == false);
985	1072	assert_or_panic(vec[104] == false);
986		assert_or_panic(vec[105] == true);
	1073	assert_or_panic(vec[105] == false);
987	1074	assert_or_panic(vec[106] == true);
988	1075	assert_or_panic(vec[107] == true);
989	1076	assert_or_panic(vec[108] == true);
990	1077	assert_or_panic(vec[109] == true);
991		assert_or_panic(vec[110] == false);
	1078	assert_or_panic(vec[110] == true);
992	1079	assert_or_panic(vec[111] == false);
993	1080	assert_or_panic(vec[112] == false);
994		assert_or_panic(vec[113] == false);
995		assert_or_panic(vec[114] == true);
	1081	assert_or_panic(vec[113] == true);
	1082	assert_or_panic(vec[114] == false);
996	1083	assert_or_panic(vec[115] == true);
997	1084	assert_or_panic(vec[116] == false);
998		assert_or_panic(vec[117] == true);
999		assert_or_panic(vec[118] == false);
	1085	assert_or_panic(vec[117] == false);
	1086	assert_or_panic(vec[118] == true);
1000	1087	assert_or_panic(vec[119] == false);
1001	1088	assert_or_panic(vec[120] == true);
1002	1089	assert_or_panic(vec[121] == false);
1003		assert_or_panic(vec[122] == false);
	1090	assert_or_panic(vec[122] == true);
1004	1091	assert_or_panic(vec[123] == true);
1005		assert_or_panic(vec[124] == false);
	1092	assert_or_panic(vec[124] == true);
1006	1093	assert_or_panic(vec[125] == true);
1007	1094	assert_or_panic(vec[126] == true);
1008	1095	assert_or_panic(vec[127] == true);
1009		assert_or_panic(vec[128] == true);
1010		assert_or_panic(vec[129] == false);
1011		assert_or_panic(vec[130] == true);
1012		assert_or_panic(vec[131] == true);
1013		assert_or_panic(vec[132] == false);
1014		assert_or_panic(vec[133] == false);
1015		assert_or_panic(vec[134] == true);
1016		assert_or_panic(vec[135] == false);
1017		assert_or_panic(vec[136] == false);
1018		assert_or_panic(vec[137] == true);
1019		assert_or_panic(vec[138] == false);
1020		assert_or_panic(vec[139] == true);
1021		assert_or_panic(vec[140] == false);
1022		assert_or_panic(vec[141] == true);
1023		assert_or_panic(vec[142] == true);
1024		assert_or_panic(vec[143] == true);
1025		assert_or_panic(vec[144] == true);
1026		assert_or_panic(vec[145] == false);
1027		assert_or_panic(vec[146] == true);
1028		assert_or_panic(vec[147] == false);
1029		assert_or_panic(vec[148] == false);
1030		assert_or_panic(vec[149] == false);
1031		assert_or_panic(vec[150] == true);
1032		assert_or_panic(vec[151] == true);
1033		assert_or_panic(vec[152] == true);
1034		assert_or_panic(vec[153] == true);
1035		assert_or_panic(vec[154] == true);
1036		assert_or_panic(vec[155] == false);
1037		assert_or_panic(vec[156] == true);
1038		assert_or_panic(vec[157] == false);
1039		assert_or_panic(vec[158] == false);
1040		assert_or_panic(vec[159] == false);
1041		assert_or_panic(vec[160] == true);
1042		assert_or_panic(vec[161] == true);
1043		assert_or_panic(vec[162] == false);
1044		assert_or_panic(vec[163] == true);
1045		assert_or_panic(vec[164] == true);
1046		assert_or_panic(vec[165] == false);
1047		assert_or_panic(vec[166] == false);
1048		assert_or_panic(vec[167] == false);
1049		assert_or_panic(vec[168] == false);
1050		assert_or_panic(vec[169] == true);
1051		assert_or_panic(vec[170] == false);
1052		assert_or_panic(vec[171] == true);
1053		assert_or_panic(vec[172] == false);
1054		assert_or_panic(vec[173] == false);
1055		assert_or_panic(vec[174] == false);
1056		assert_or_panic(vec[175] == false);
1057		assert_or_panic(vec[176] == true);
1058		assert_or_panic(vec[177] == true);
1059		assert_or_panic(vec[178] == true);
1060		assert_or_panic(vec[179] == false);
1061		assert_or_panic(vec[180] == true);
1062		assert_or_panic(vec[181] == false);
1063		assert_or_panic(vec[182] == true);
1064		assert_or_panic(vec[183] == true);
1065		assert_or_panic(vec[184] == false);
1066		assert_or_panic(vec[185] == false);
1067		assert_or_panic(vec[186] == true);
1068		assert_or_panic(vec[187] == false);
1069		assert_or_panic(vec[188] == false);
1070		assert_or_panic(vec[189] == false);
1071		assert_or_panic(vec[190] == false);
1072		assert_or_panic(vec[191] == true);
1073		assert_or_panic(vec[192] == true);
1074		assert_or_panic(vec[193] == true);
1075		assert_or_panic(vec[194] == true);
1076		assert_or_panic(vec[195] == true);
1077		assert_or_panic(vec[196] == true);
1078		assert_or_panic(vec[197] == true);
1079		assert_or_panic(vec[198] == false);
1080		assert_or_panic(vec[199] == true);
1081		assert_or_panic(vec[200] == false);
1082		assert_or_panic(vec[201] == false);
1083		assert_or_panic(vec[202] == true);
1084		assert_or_panic(vec[203] == false);
1085		assert_or_panic(vec[204] == true);
1086		assert_or_panic(vec[205] == true);
1087		assert_or_panic(vec[206] == true);
1088		assert_or_panic(vec[207] == false);
1089		assert_or_panic(vec[208] == false);
1090		assert_or_panic(vec[209] == true);
1091		assert_or_panic(vec[210] == true);
1092		assert_or_panic(vec[211] == true);
1093		assert_or_panic(vec[212] == false);
1094		assert_or_panic(vec[213] == true);
1095		assert_or_panic(vec[214] == true);
1096		assert_or_panic(vec[215] == true);
1097		assert_or_panic(vec[216] == true);
1098		assert_or_panic(vec[217] == true);
1099		assert_or_panic(vec[218] == false);
1100		assert_or_panic(vec[219] == false);
1101		assert_or_panic(vec[220] == false);
1102		assert_or_panic(vec[221] == false);
1103		assert_or_panic(vec[222] == false);
1104		assert_or_panic(vec[223] == true);
1105		assert_or_panic(vec[224] == true);
1106		assert_or_panic(vec[225] == false);
1107		assert_or_panic(vec[226] == true);
1108		assert_or_panic(vec[227] == false);
1109		assert_or_panic(vec[228] == false);
1110		assert_or_panic(vec[229] == true);
1111		assert_or_panic(vec[230] == false);
1112		assert_or_panic(vec[231] == true);
1113		assert_or_panic(vec[232] == false);
1114		assert_or_panic(vec[233] == false);
1115		assert_or_panic(vec[234] == false);
1116		assert_or_panic(vec[235] == true);
1117		assert_or_panic(vec[236] == false);
1118		assert_or_panic(vec[237] == false);
1119		assert_or_panic(vec[238] == false);
1120		assert_or_panic(vec[239] == true);
1121		assert_or_panic(vec[240] == true);
1122		assert_or_panic(vec[241] == true);
1123		assert_or_panic(vec[242] == true);
1124		assert_or_panic(vec[243] == true);
1125		assert_or_panic(vec[244] == true);
1126		assert_or_panic(vec[245] == false);
1127		assert_or_panic(vec[246] == false);
1128		assert_or_panic(vec[247] == true);
1129		assert_or_panic(vec[248] == false);
1130		assert_or_panic(vec[249] == true);
1131		assert_or_panic(vec[250] == true);
1132		assert_or_panic(vec[251] == false);
1133		assert_or_panic(vec[252] == true);
1134		assert_or_panic(vec[253] == true);
1135		assert_or_panic(vec[254] == true);
1136		assert_or_panic(vec[255] == false);
1137	1096	}
1138
1139		void c_vector_512_bool(Vector512Bool vec) {
	1097	void c_test_vector_128_bool(void) {
	1098	Vector_128_bool vec = zig_ret_vector_128_bool();
1140	1099	assert_or_panic(vec[0] == true);
1141	1100	assert_or_panic(vec[1] == true);
1142		assert_or_panic(vec[2] == true);
1143		assert_or_panic(vec[3] == true);
1144		assert_or_panic(vec[4] == true);
1145		assert_or_panic(vec[5] == false);
1146		assert_or_panic(vec[6] == false);
1147		assert_or_panic(vec[7] == true);
1148		assert_or_panic(vec[8] == true);
	1101	assert_or_panic(vec[2] == false);
	1102	assert_or_panic(vec[3] == false);
	1103	assert_or_panic(vec[4] == false);
	1104	assert_or_panic(vec[5] == true);
	1105	assert_or_panic(vec[6] == true);
	1106	assert_or_panic(vec[7] == false);
	1107	assert_or_panic(vec[8] == false);
1149	1108	assert_or_panic(vec[9] == true);
1150		assert_or_panic(vec[10] == true);
	1109	assert_or_panic(vec[10] == false);
1151	1110	assert_or_panic(vec[11] == false);
1152		assert_or_panic(vec[12] == true);
	1111	assert_or_panic(vec[12] == false);
1153	1112	assert_or_panic(vec[13] == true);
1154	1113	assert_or_panic(vec[14] == false);
1155		assert_or_panic(vec[15] == false);
1156		assert_or_panic(vec[16] == false);
1157		assert_or_panic(vec[17] == true);
1158		assert_or_panic(vec[18] == true);
	1114	assert_or_panic(vec[15] == true);
	1115	assert_or_panic(vec[16] == true);
	1116	assert_or_panic(vec[17] == false);
	1117	assert_or_panic(vec[18] == false);
1159	1118	assert_or_panic(vec[19] == true);
1160	1119	assert_or_panic(vec[20] == true);
1161	1120	assert_or_panic(vec[21] == true);
1162		assert_or_panic(vec[22] == false);
1163		assert_or_panic(vec[23] == false);
1164		assert_or_panic(vec[24] == true);
1165		assert_or_panic(vec[25] == true);
1166		assert_or_panic(vec[26] == false);
1167		assert_or_panic(vec[27] == false);
1168		assert_or_panic(vec[28] == false);
	1121	assert_or_panic(vec[22] == true);
	1122	assert_or_panic(vec[23] == true);
	1123	assert_or_panic(vec[24] == false);
	1124	assert_or_panic(vec[25] == false);
	1125	assert_or_panic(vec[26] == true);
	1126	assert_or_panic(vec[27] == true);
	1127	assert_or_panic(vec[28] == true);
1169	1128	assert_or_panic(vec[29] == false);
1170	1129	assert_or_panic(vec[30] == false);
1171	1130	assert_or_panic(vec[31] == true);
...	...	@@ -1174,519 +1133,110 @@ void c_vector_512_bool(Vector512Bool vec) {
1174	1133	assert_or_panic(vec[34] == true);
1175	1134	assert_or_panic(vec[35] == true);
1176	1135	assert_or_panic(vec[36] == true);
1177		assert_or_panic(vec[37] == true);
	1136	assert_or_panic(vec[37] == false);
1178	1137	assert_or_panic(vec[38] == true);
1179	1138	assert_or_panic(vec[39] == true);
1180		assert_or_panic(vec[40] == false);
1181		assert_or_panic(vec[41] == true);
	1139	assert_or_panic(vec[40] == true);
	1140	assert_or_panic(vec[41] == false);
1182	1141	assert_or_panic(vec[42] == true);
1183		assert_or_panic(vec[43] == false);
	1142	assert_or_panic(vec[43] == true);
1184	1143	assert_or_panic(vec[44] == false);
1185	1144	assert_or_panic(vec[45] == false);
1186		assert_or_panic(vec[46] == true);
	1145	assert_or_panic(vec[46] == false);
1187	1146	assert_or_panic(vec[47] == true);
1188	1147	assert_or_panic(vec[48] == false);
1189		assert_or_panic(vec[49] == true);
	1148	assert_or_panic(vec[49] == false);
1190	1149	assert_or_panic(vec[50] == false);
1191		assert_or_panic(vec[51] == true);
	1150	assert_or_panic(vec[51] == false);
1192	1151	assert_or_panic(vec[52] == true);
1193	1152	assert_or_panic(vec[53] == false);
1194	1153	assert_or_panic(vec[54] == true);
1195	1154	assert_or_panic(vec[55] == false);
1196		assert_or_panic(vec[56] == false);
1197		assert_or_panic(vec[57] == true);
1198		assert_or_panic(vec[58] == true);
1199		assert_or_panic(vec[59] == false);
	1155	assert_or_panic(vec[56] == true);
	1156	assert_or_panic(vec[57] == false);
	1157	assert_or_panic(vec[58] == false);
	1158	assert_or_panic(vec[59] == true);
1200	1159	assert_or_panic(vec[60] == true);
1201	1160	assert_or_panic(vec[61] == true);
1202		assert_or_panic(vec[62] == false);
	1161	assert_or_panic(vec[62] == true);
1203	1162	assert_or_panic(vec[63] == true);
1204	1163	assert_or_panic(vec[64] == false);
1205		assert_or_panic(vec[65] == true);
1206		assert_or_panic(vec[66] == true);
	1164	assert_or_panic(vec[65] == false);
	1165	assert_or_panic(vec[66] == false);
1207	1166	assert_or_panic(vec[67] == true);
1208	1167	assert_or_panic(vec[68] == true);
1209		assert_or_panic(vec[69] == true);
	1168	assert_or_panic(vec[69] == false);
1210	1169	assert_or_panic(vec[70] == true);
1211	1170	assert_or_panic(vec[71] == true);
1212		assert_or_panic(vec[72] == true);
	1171	assert_or_panic(vec[72] == false);
1213	1172	assert_or_panic(vec[73] == true);
1214		assert_or_panic(vec[74] == false);
1215		assert_or_panic(vec[75] == true);
	1173	assert_or_panic(vec[74] == true);
	1174	assert_or_panic(vec[75] == false);
1216	1175	assert_or_panic(vec[76] == false);
1217	1176	assert_or_panic(vec[77] == true);
1218	1177	assert_or_panic(vec[78] == false);
1219		assert_or_panic(vec[79] == false);
	1178	assert_or_panic(vec[79] == true);
1220	1179	assert_or_panic(vec[80] == false);
1221		assert_or_panic(vec[81] == true);
1222		assert_or_panic(vec[82] == false);
	1180	assert_or_panic(vec[81] == false);
	1181	assert_or_panic(vec[82] == true);
1223	1182	assert_or_panic(vec[83] == true);
1224		assert_or_panic(vec[84] == true);
1225		assert_or_panic(vec[85] == false);
1226		assert_or_panic(vec[86] == true);
1227		assert_or_panic(vec[87] == true);
	1183	assert_or_panic(vec[84] == false);
	1184	assert_or_panic(vec[85] == true);
	1185	assert_or_panic(vec[86] == false);
	1186	assert_or_panic(vec[87] == false);
1228	1187	assert_or_panic(vec[88] == true);
1229		assert_or_panic(vec[89] == false);
	1188	assert_or_panic(vec[89] == true);
1230	1189	assert_or_panic(vec[90] == true);
1231	1190	assert_or_panic(vec[91] == true);
1232		assert_or_panic(vec[92] == false);
1233		assert_or_panic(vec[93] == true);
	1191	assert_or_panic(vec[92] == true);
	1192	assert_or_panic(vec[93] == false);
1234	1193	assert_or_panic(vec[94] == false);
1235	1194	assert_or_panic(vec[95] == true);
1236		assert_or_panic(vec[96] == true);
	1195	assert_or_panic(vec[96] == false);
1237	1196	assert_or_panic(vec[97] == false);
1238		assert_or_panic(vec[98] == false);
1239		assert_or_panic(vec[99] == false);
	1197	assert_or_panic(vec[98] == true);
	1198	assert_or_panic(vec[99] == true);
1240	1199	assert_or_panic(vec[100] == true);
1241	1200	assert_or_panic(vec[101] == true);
1242		assert_or_panic(vec[102] == false);
	1201	assert_or_panic(vec[102] == true);
1243	1202	assert_or_panic(vec[103] == true);
1244		assert_or_panic(vec[104] == false);
	1203	assert_or_panic(vec[104] == true);
1245	1204	assert_or_panic(vec[105] == false);
1246		assert_or_panic(vec[106] == true);
1247		assert_or_panic(vec[107] == false);
	1205	assert_or_panic(vec[106] == false);
	1206	assert_or_panic(vec[107] == true);
1248	1207	assert_or_panic(vec[108] == false);
1249		assert_or_panic(vec[109] == true);
1250		assert_or_panic(vec[110] == false);
	1208	assert_or_panic(vec[109] == false);
	1209	assert_or_panic(vec[110] == true);
1251	1210	assert_or_panic(vec[111] == false);
1252	1211	assert_or_panic(vec[112] == false);
1253		assert_or_panic(vec[113] == false);
	1212	assert_or_panic(vec[113] == true);
1254	1213	assert_or_panic(vec[114] == false);
1255		assert_or_panic(vec[115] == true);
1256		assert_or_panic(vec[116] == true);
	1214	assert_or_panic(vec[115] == false);
	1215	assert_or_panic(vec[116] == false);
1257	1216	assert_or_panic(vec[117] == false);
1258	1217	assert_or_panic(vec[118] == false);
1259	1218	assert_or_panic(vec[119] == false);
1260		assert_or_panic(vec[120] == false);
	1219	assert_or_panic(vec[120] == true);
1261	1220	assert_or_panic(vec[121] == true);
1262		assert_or_panic(vec[122] == false);
	1221	assert_or_panic(vec[122] == true);
1263	1222	assert_or_panic(vec[123] == false);
1264	1223	assert_or_panic(vec[124] == true);
1265		assert_or_panic(vec[125] == true);
	1224	assert_or_panic(vec[125] == false);
1266	1225	assert_or_panic(vec[126] == false);
1267	1226	assert_or_panic(vec[127] == true);
1268		assert_or_panic(vec[128] == false);
1269		assert_or_panic(vec[129] == true);
1270		assert_or_panic(vec[130] == true);
1271		assert_or_panic(vec[131] == false);
1272		assert_or_panic(vec[132] == true);
1273		assert_or_panic(vec[133] == false);
1274		assert_or_panic(vec[134] == false);
1275		assert_or_panic(vec[135] == false);
1276		assert_or_panic(vec[136] == false);
1277		assert_or_panic(vec[137] == true);
1278		assert_or_panic(vec[138] == true);
1279		assert_or_panic(vec[139] == false);
1280		assert_or_panic(vec[140] == false);
1281		assert_or_panic(vec[141] == false);
1282		assert_or_panic(vec[142] == true);
1283		assert_or_panic(vec[143] == true);
1284		assert_or_panic(vec[144] == false);
1285		assert_or_panic(vec[145] == false);
1286		assert_or_panic(vec[146] == true);
1287		assert_or_panic(vec[147] == true);
1288		assert_or_panic(vec[148] == true);
1289		assert_or_panic(vec[149] == true);
1290		assert_or_panic(vec[150] == true);
1291		assert_or_panic(vec[151] == true);
1292		assert_or_panic(vec[152] == true);
1293		assert_or_panic(vec[153] == false);
1294		assert_or_panic(vec[154] == true);
1295		assert_or_panic(vec[155] == false);
1296		assert_or_panic(vec[156] == false);
1297		assert_or_panic(vec[157] == true);
1298		assert_or_panic(vec[158] == false);
1299		assert_or_panic(vec[159] == true);
1300		assert_or_panic(vec[160] == false);
1301		assert_or_panic(vec[161] == true);
1302		assert_or_panic(vec[162] == true);
1303		assert_or_panic(vec[163] == true);
1304		assert_or_panic(vec[164] == true);
1305		assert_or_panic(vec[165] == true);
1306		assert_or_panic(vec[166] == true);
1307		assert_or_panic(vec[167] == true);
1308		assert_or_panic(vec[168] == true);
1309		assert_or_panic(vec[169] == false);
1310		assert_or_panic(vec[170] == true);
1311		assert_or_panic(vec[171] == true);
1312		assert_or_panic(vec[172] == false);
1313		assert_or_panic(vec[173] == true);
1314		assert_or_panic(vec[174] == true);
1315		assert_or_panic(vec[175] == false);
1316		assert_or_panic(vec[176] == false);
1317		assert_or_panic(vec[177] == false);
1318		assert_or_panic(vec[178] == true);
1319		assert_or_panic(vec[179] == false);
1320		assert_or_panic(vec[180] == false);
1321		assert_or_panic(vec[181] == true);
1322		assert_or_panic(vec[182] == true);
1323		assert_or_panic(vec[183] == true);
1324		assert_or_panic(vec[184] == true);
1325		assert_or_panic(vec[185] == true);
1326		assert_or_panic(vec[186] == true);
1327		assert_or_panic(vec[187] == true);
1328		assert_or_panic(vec[188] == true);
1329		assert_or_panic(vec[189] == true);
1330		assert_or_panic(vec[190] == false);
1331		assert_or_panic(vec[191] == true);
1332		assert_or_panic(vec[192] == true);
1333		assert_or_panic(vec[193] == false);
1334		assert_or_panic(vec[194] == false);
1335		assert_or_panic(vec[195] == true);
1336		assert_or_panic(vec[196] == true);
1337		assert_or_panic(vec[197] == false);
1338		assert_or_panic(vec[198] == true);
1339		assert_or_panic(vec[199] == true);
1340		assert_or_panic(vec[200] == false);
1341		assert_or_panic(vec[201] == true);
1342		assert_or_panic(vec[202] == true);
1343		assert_or_panic(vec[203] == false);
1344		assert_or_panic(vec[204] == true);
1345		assert_or_panic(vec[205] == true);
1346		assert_or_panic(vec[206] == true);
1347		assert_or_panic(vec[207] == true);
1348		assert_or_panic(vec[208] == false);
1349		assert_or_panic(vec[209] == true);
1350		assert_or_panic(vec[210] == false);
1351		assert_or_panic(vec[211] == true);
1352		assert_or_panic(vec[212] == true);
1353		assert_or_panic(vec[213] == false);
1354		assert_or_panic(vec[214] == true);
1355		assert_or_panic(vec[215] == false);
1356		assert_or_panic(vec[216] == true);
1357		assert_or_panic(vec[217] == false);
1358		assert_or_panic(vec[218] == true);
1359		assert_or_panic(vec[219] == false);
1360		assert_or_panic(vec[220] == false);
1361		assert_or_panic(vec[221] == true);
1362		assert_or_panic(vec[222] == false);
1363		assert_or_panic(vec[223] == false);
1364		assert_or_panic(vec[224] == false);
1365		assert_or_panic(vec[225] == true);
1366		assert_or_panic(vec[226] == true);
1367		assert_or_panic(vec[227] == false);
1368		assert_or_panic(vec[228] == false);
1369		assert_or_panic(vec[229] == false);
1370		assert_or_panic(vec[230] == true);
1371		assert_or_panic(vec[231] == false);
1372		assert_or_panic(vec[232] == true);
1373		assert_or_panic(vec[233] == false);
1374		assert_or_panic(vec[234] == false);
1375		assert_or_panic(vec[235] == false);
1376		assert_or_panic(vec[236] == true);
1377		assert_or_panic(vec[237] == true);
1378		assert_or_panic(vec[238] == false);
1379		assert_or_panic(vec[239] == false);
1380		assert_or_panic(vec[240] == false);
1381		assert_or_panic(vec[241] == false);
1382		assert_or_panic(vec[242] == false);
1383		assert_or_panic(vec[243] == true);
1384		assert_or_panic(vec[244] == true);
1385		assert_or_panic(vec[245] == false);
1386		assert_or_panic(vec[246] == true);
1387		assert_or_panic(vec[247] == false);
1388		assert_or_panic(vec[248] == false);
1389		assert_or_panic(vec[249] == true);
1390		assert_or_panic(vec[250] == false);
1391		assert_or_panic(vec[251] == false);
1392		assert_or_panic(vec[252] == false);
1393		assert_or_panic(vec[253] == true);
1394		assert_or_panic(vec[254] == false);
1395		assert_or_panic(vec[255] == false);
1396		assert_or_panic(vec[256] == false);
1397		assert_or_panic(vec[257] == false);
1398		assert_or_panic(vec[258] == true);
1399		assert_or_panic(vec[259] == true);
1400		assert_or_panic(vec[260] == true);
1401		assert_or_panic(vec[261] == true);
1402		assert_or_panic(vec[262] == false);
1403		assert_or_panic(vec[263] == true);
1404		assert_or_panic(vec[264] == false);
1405		assert_or_panic(vec[265] == false);
1406		assert_or_panic(vec[266] == false);
1407		assert_or_panic(vec[267] == true);
1408		assert_or_panic(vec[268] == false);
1409		assert_or_panic(vec[269] == false);
1410		assert_or_panic(vec[270] == true);
1411		assert_or_panic(vec[271] == true);
1412		assert_or_panic(vec[272] == false);
1413		assert_or_panic(vec[273] == false);
1414		assert_or_panic(vec[274] == false);
1415		assert_or_panic(vec[275] == false);
1416		assert_or_panic(vec[276] == false);
1417		assert_or_panic(vec[277] == true);
1418		assert_or_panic(vec[278] == false);
1419		assert_or_panic(vec[279] == true);
1420		assert_or_panic(vec[280] == true);
1421		assert_or_panic(vec[281] == true);
1422		assert_or_panic(vec[282] == true);
1423		assert_or_panic(vec[283] == true);
1424		assert_or_panic(vec[284] == false);
1425		assert_or_panic(vec[285] == false);
1426		assert_or_panic(vec[286] == false);
1427		assert_or_panic(vec[287] == false);
1428		assert_or_panic(vec[288] == false);
1429		assert_or_panic(vec[289] == false);
1430		assert_or_panic(vec[290] == false);
1431		assert_or_panic(vec[291] == false);
1432		assert_or_panic(vec[292] == false);
1433		assert_or_panic(vec[293] == true);
1434		assert_or_panic(vec[294] == true);
1435		assert_or_panic(vec[295] == true);
1436		assert_or_panic(vec[296] == true);
1437		assert_or_panic(vec[297] == true);
1438		assert_or_panic(vec[298] == true);
1439		assert_or_panic(vec[299] == false);
1440		assert_or_panic(vec[300] == true);
1441		assert_or_panic(vec[301] == false);
1442		assert_or_panic(vec[302] == true);
1443		assert_or_panic(vec[303] == true);
1444		assert_or_panic(vec[304] == true);
1445		assert_or_panic(vec[305] == false);
1446		assert_or_panic(vec[306] == false);
1447		assert_or_panic(vec[307] == true);
1448		assert_or_panic(vec[308] == true);
1449		assert_or_panic(vec[309] == true);
1450		assert_or_panic(vec[310] == false);
1451		assert_or_panic(vec[311] == true);
1452		assert_or_panic(vec[312] == true);
1453		assert_or_panic(vec[313] == true);
1454		assert_or_panic(vec[314] == false);
1455		assert_or_panic(vec[315] == true);
1456		assert_or_panic(vec[316] == true);
1457		assert_or_panic(vec[317] == true);
1458		assert_or_panic(vec[318] == false);
1459		assert_or_panic(vec[319] == true);
1460		assert_or_panic(vec[320] == true);
1461		assert_or_panic(vec[321] == false);
1462		assert_or_panic(vec[322] == false);
1463		assert_or_panic(vec[323] == true);
1464		assert_or_panic(vec[324] == false);
1465		assert_or_panic(vec[325] == false);
1466		assert_or_panic(vec[326] == false);
1467		assert_or_panic(vec[327] == false);
1468		assert_or_panic(vec[328] == true);
1469		assert_or_panic(vec[329] == false);
1470		assert_or_panic(vec[330] == true);
1471		assert_or_panic(vec[331] == true);
1472		assert_or_panic(vec[332] == true);
1473		assert_or_panic(vec[333] == true);
1474		assert_or_panic(vec[334] == false);
1475		assert_or_panic(vec[335] == false);
1476		assert_or_panic(vec[336] == true);
1477		assert_or_panic(vec[337] == false);
1478		assert_or_panic(vec[338] == true);
1479		assert_or_panic(vec[339] == false);
1480		assert_or_panic(vec[340] == false);
1481		assert_or_panic(vec[341] == false);
1482		assert_or_panic(vec[342] == true);
1483		assert_or_panic(vec[343] == false);
1484		assert_or_panic(vec[344] == true);
1485		assert_or_panic(vec[345] == false);
1486		assert_or_panic(vec[346] == false);
1487		assert_or_panic(vec[347] == true);
1488		assert_or_panic(vec[348] == true);
1489		assert_or_panic(vec[349] == true);
1490		assert_or_panic(vec[350] == true);
1491		assert_or_panic(vec[351] == false);
1492		assert_or_panic(vec[352] == false);
1493		assert_or_panic(vec[353] == false);
1494		assert_or_panic(vec[354] == true);
1495		assert_or_panic(vec[355] == true);
1496		assert_or_panic(vec[356] == false);
1497		assert_or_panic(vec[357] == true);
1498		assert_or_panic(vec[358] == false);
1499		assert_or_panic(vec[359] == false);
1500		assert_or_panic(vec[360] == true);
1501		assert_or_panic(vec[361] == false);
1502		assert_or_panic(vec[362] == true);
1503		assert_or_panic(vec[363] == false);
1504		assert_or_panic(vec[364] == true);
1505		assert_or_panic(vec[365] == true);
1506		assert_or_panic(vec[366] == false);
1507		assert_or_panic(vec[367] == false);
1508		assert_or_panic(vec[368] == true);
1509		assert_or_panic(vec[369] == true);
1510		assert_or_panic(vec[370] == true);
1511		assert_or_panic(vec[371] == true);
1512		assert_or_panic(vec[372] == false);
1513		assert_or_panic(vec[373] == false);
1514		assert_or_panic(vec[374] == true);
1515		assert_or_panic(vec[375] == false);
1516		assert_or_panic(vec[376] == true);
1517		assert_or_panic(vec[377] == true);
1518		assert_or_panic(vec[378] == false);
1519		assert_or_panic(vec[379] == true);
1520		assert_or_panic(vec[380] == true);
1521		assert_or_panic(vec[381] == false);
1522		assert_or_panic(vec[382] == true);
1523		assert_or_panic(vec[383] == true);
1524		assert_or_panic(vec[384] == true);
1525		assert_or_panic(vec[385] == false);
1526		assert_or_panic(vec[386] == true);
1527		assert_or_panic(vec[387] == true);
1528		assert_or_panic(vec[388] == true);
1529		assert_or_panic(vec[389] == false);
1530		assert_or_panic(vec[390] == false);
1531		assert_or_panic(vec[391] == true);
1532		assert_or_panic(vec[392] == false);
1533		assert_or_panic(vec[393] == true);
1534		assert_or_panic(vec[394] == true);
1535		assert_or_panic(vec[395] == true);
1536		assert_or_panic(vec[396] == false);
1537		assert_or_panic(vec[397] == false);
1538		assert_or_panic(vec[398] == false);
1539		assert_or_panic(vec[399] == false);
1540		assert_or_panic(vec[400] == false);
1541		assert_or_panic(vec[401] == true);
1542		assert_or_panic(vec[402] == false);
1543		assert_or_panic(vec[403] == false);
1544		assert_or_panic(vec[404] == false);
1545		assert_or_panic(vec[405] == false);
1546		assert_or_panic(vec[406] == true);
1547		assert_or_panic(vec[407] == false);
1548		assert_or_panic(vec[408] == false);
1549		assert_or_panic(vec[409] == true);
1550		assert_or_panic(vec[410] == true);
1551		assert_or_panic(vec[411] == false);
1552		assert_or_panic(vec[412] == false);
1553		assert_or_panic(vec[413] == false);
1554		assert_or_panic(vec[414] == false);
1555		assert_or_panic(vec[415] == true);
1556		assert_or_panic(vec[416] == true);
1557		assert_or_panic(vec[417] == true);
1558		assert_or_panic(vec[418] == true);
1559		assert_or_panic(vec[419] == true);
1560		assert_or_panic(vec[420] == false);
1561		assert_or_panic(vec[421] == false);
1562		assert_or_panic(vec[422] == false);
1563		assert_or_panic(vec[423] == true);
1564		assert_or_panic(vec[424] == false);
1565		assert_or_panic(vec[425] == false);
1566		assert_or_panic(vec[426] == false);
1567		assert_or_panic(vec[427] == false);
1568		assert_or_panic(vec[428] == true);
1569		assert_or_panic(vec[429] == false);
1570		assert_or_panic(vec[430] == true);
1571		assert_or_panic(vec[431] == false);
1572		assert_or_panic(vec[432] == true);
1573		assert_or_panic(vec[433] == true);
1574		assert_or_panic(vec[434] == true);
1575		assert_or_panic(vec[435] == true);
1576		assert_or_panic(vec[436] == false);
1577		assert_or_panic(vec[437] == false);
1578		assert_or_panic(vec[438] == false);
1579		assert_or_panic(vec[439] == false);
1580		assert_or_panic(vec[440] == false);
1581		assert_or_panic(vec[441] == true);
1582		assert_or_panic(vec[442] == true);
1583		assert_or_panic(vec[443] == true);
1584		assert_or_panic(vec[444] == true);
1585		assert_or_panic(vec[445] == true);
1586		assert_or_panic(vec[446] == true);
1587		assert_or_panic(vec[447] == true);
1588		assert_or_panic(vec[448] == true);
1589		assert_or_panic(vec[449] == true);
1590		assert_or_panic(vec[450] == false);
1591		assert_or_panic(vec[451] == false);
1592		assert_or_panic(vec[452] == true);
1593		assert_or_panic(vec[453] == false);
1594		assert_or_panic(vec[454] == true);
1595		assert_or_panic(vec[455] == false);
1596		assert_or_panic(vec[456] == false);
1597		assert_or_panic(vec[457] == true);
1598		assert_or_panic(vec[458] == false);
1599		assert_or_panic(vec[459] == false);
1600		assert_or_panic(vec[460] == true);
1601		assert_or_panic(vec[461] == true);
1602		assert_or_panic(vec[462] == true);
1603		assert_or_panic(vec[463] == true);
1604		assert_or_panic(vec[464] == true);
1605		assert_or_panic(vec[465] == true);
1606		assert_or_panic(vec[466] == false);
1607		assert_or_panic(vec[467] == true);
1608		assert_or_panic(vec[468] == false);
1609		assert_or_panic(vec[469] == false);
1610		assert_or_panic(vec[470] == false);
1611		assert_or_panic(vec[471] == true);
1612		assert_or_panic(vec[472] == true);
1613		assert_or_panic(vec[473] == false);
1614		assert_or_panic(vec[474] == true);
1615		assert_or_panic(vec[475] == true);
1616		assert_or_panic(vec[476] == false);
1617		assert_or_panic(vec[477] == false);
1618		assert_or_panic(vec[478] == true);
1619		assert_or_panic(vec[479] == true);
1620		assert_or_panic(vec[480] == false);
1621		assert_or_panic(vec[481] == false);
1622		assert_or_panic(vec[482] == true);
1623		assert_or_panic(vec[483] == true);
1624		assert_or_panic(vec[484] == false);
1625		assert_or_panic(vec[485] == true);
1626		assert_or_panic(vec[486] == false);
1627		assert_or_panic(vec[487] == true);
1628		assert_or_panic(vec[488] == true);
1629		assert_or_panic(vec[489] == true);
1630		assert_or_panic(vec[490] == true);
1631		assert_or_panic(vec[491] == true);
1632		assert_or_panic(vec[492] == true);
1633		assert_or_panic(vec[493] == true);
1634		assert_or_panic(vec[494] == true);
1635		assert_or_panic(vec[495] == true);
1636		assert_or_panic(vec[496] == false);
1637		assert_or_panic(vec[497] == true);
1638		assert_or_panic(vec[498] == true);
1639		assert_or_panic(vec[499] == true);
1640		assert_or_panic(vec[500] == false);
1641		assert_or_panic(vec[501] == false);
1642		assert_or_panic(vec[502] == true);
1643		assert_or_panic(vec[503] == false);
1644		assert_or_panic(vec[504] == false);
1645		assert_or_panic(vec[505] == false);
1646		assert_or_panic(vec[506] == true);
1647		assert_or_panic(vec[507] == true);
1648		assert_or_panic(vec[508] == false);
1649		assert_or_panic(vec[509] == true);
1650		assert_or_panic(vec[510] == false);
1651		assert_or_panic(vec[511] == true);
1652		}
1653
1654		#endif
1655
1656		Vector2Bool c_ret_vector_2_bool(void) {
1657		return (Vector2Bool){
	1227	zig_vector_128_bool((Vector_128_bool){
1658	1228	true,
1659		false,
1660		};
1661		}
1662
1663		Vector4Bool c_ret_vector_4_bool(void) {
1664		return (Vector4Bool){
1665	1229	true,
1666	1230	false,
1667	1231	true,
1668		false,
1669		};
1670		}
1671
1672		Vector8Bool c_ret_vector_8_bool(void) {
1673		return (Vector8Bool){
1674		false,
1675	1232	true,
1676	1233	false,
1677	1234	false,
1678	1235	true,
1679		false,
1680		false,
1681	1236	true,
1682		};
1683		}
1684
1685		Vector16Bool c_ret_vector_16_bool(void) {
1686		return (Vector16Bool){
1687	1237	true,
1688	1238	true,
1689		false,
	1239	true,
1690	1240	false,
1691	1241	false,
1692	1242	false,
...	...	@@ -1696,39 +1246,26 @@ Vector16Bool c_ret_vector_16_bool(void) {
1696	1246	false,
1697	1247	false,
1698	1248	true,
1699		true,
1700	1249	false,
1701		true,
1702		true,
1703		};
1704		}
1705
1706		Vector32Bool c_ret_vector_32_bool(void) {
1707		return (Vector32Bool){
1708	1250	true,
1709	1251	false,
1710		true,
1711		true,
1712		true,
1713	1252	false,
1714		true,
1715	1253	false,
1716	1254	true,
1717		true,
1718		true,
1719	1255	false,
1720	1256	true,
1721	1257	true,
1722	1258	false,
	1259	true,
1723	1260	false,
1724	1261	true,
	1262	true,
1725	1263	false,
1726	1264	false,
1727	1265	false,
1728	1266	false,
1729	1267	true,
1730	1268	true,
1731		true,
1732	1269	false,
1733	1270	true,
1734	1271	false,
...	...	@@ -1736,29 +1273,29 @@ Vector32Bool c_ret_vector_32_bool(void) {
1736	1273	true,
1737	1274	false,
1738	1275	false,
	1276	true,
	1277	true,
1739	1278	false,
1740		};
1741		}
1742
1743		Vector64Bool c_ret_vector_64_bool(void) {
1744		return (Vector64Bool){
1745	1279	false,
1746	1280	true,
1747	1281	false,
	1282	false,
1748	1283	true,
1749	1284	true,
1750	1285	true,
1751		false,
1752	1286	true,
1753	1287	true,
1754	1288	true,
1755	1289	true,
1756	1290	true,
	1291	false,
	1292	false,
1757	1293	true,
1758	1294	false,
1759	1295	true,
1760	1296	true,
1761	1297	true,
	1298	true,
1762	1299	false,
1763	1300	false,
1764	1301	false,
...	...	@@ -1766,37 +1303,22 @@ Vector64Bool c_ret_vector_64_bool(void) {
1766	1303	true,
1767	1304	false,
1768	1305	true,
1769		false,
1770		true,
1771		false,
1772	1306	true,
1773		false,
1774	1307	true,
1775		false,
1776	1308	true,
1777	1309	false,
1778		false,
1779	1310	true,
1780	1311	true,
1781		false,
1782		false,
1783		false,
1784	1312	true,
1785	1313	true,
1786	1314	true,
1787	1315	true,
1788	1316	false,
1789		false,
1790		false,
1791	1317	true,
1792	1318	true,
1793		false,
1794		false,
1795	1319	true,
1796		false,
1797		false,
1798		false,
1799		false,
	1320	true,
	1321	true,
1800	1322	true,
1801	1323	false,
1802	1324	false,
...	...	@@ -1806,144 +1328,41 @@ Vector64Bool c_ret_vector_64_bool(void) {
1806	1328	true,
1807	1329	true,
1808	1330	true,
1809		};
1810		}
1811
1812		Vector128Bool c_ret_vector_128_bool(void) {
1813		return (Vector128Bool){
1814		false,
1815	1331	true,
1816	1332	true,
1817	1333	false,
1818		true,
	1334	false,
	1335	false,
1819	1336	false,
1820	1337	false,
1821	1338	true,
1822	1339	true,
1823		false,
1824	1340	true,
1825	1341	false,
1826	1342	false,
1827	1343	false,
1828		true,
	1344	false,
1829	1345	false,
1830	1346	true,
1831	1347	false,
1832	1348	false,
1833		true,
1834	1349	false,
1835		true,
1836		false,
1837		false,
1838		false,
1839		true,
1840		true,
1841		true,
1842		false,
1843		false,
1844		false,
1845		false,
1846		true,
1847		true,
1848		true,
1849		false,
1850		true,
1851		true,
1852		false,
1853		false,
1854		false,
1855		false,
1856		true,
1857		true,
1858		true,
1859		false,
1860		false,
1861		false,
1862		false,
1863		true,
1864		false,
1865		false,
1866		true,
1867		false,
1868		false,
1869		false,
1870		false,
1871		false,
1872		true,
1873		true,
1874		true,
1875		false,
1876		true,
1877		true,
1878		false,
1879		false,
1880		false,
1881		false,
1882		false,
1883		false,
1884		false,
1885		false,
1886		true,
1887		true,
1888		true,
1889		true,
1890		true,
1891		false,
1892		false,
1893		false,
1894		false,
1895		false,
1896		false,
1897		true,
1898		false,
1899		true,
1900		false,
1901		true,
1902		false,
1903		true,
1904		false,
1905		true,
1906		true,
1907		true,
1908		true,
1909		false,
1910		false,
1911		true,
1912		false,
1913		false,
1914		true,
1915		true,
1916		true,
1917		true,
1918		false,
1919		true,
1920		true,
1921		true,
1922		false,
1923		false,
1924		true,
1925		false,
1926		false,
1927		true,
1928		true,
1929		false,
1930		true,
1931	1350	false,
1932	1351	true,
1933	1352	true,
1934		true,
1935		true,
1936		true,
1937		false,
1938	1353	false,
1939	1354	true,
1940	1355	false,
1941		true,
1942		};
	1356	});
1943	1357	}
1944	1358
1945		Vector256Bool c_ret_vector_256_bool(void) {
1946		return (Vector256Bool){
	1359	typedef bool Vector_256_bool __attribute__((ext_vector_type(256)));
	1360
	1361	Vector_256_bool zig_ret_vector_256_bool(void);
	1362	void zig_vector_256_bool(Vector_256_bool vec);
	1363
	1364	Vector_256_bool c_ret_vector_256_bool(void) {
	1365	return (Vector_256_bool){
1947	1366	true,
1948	1367	false,
1949	1368	true,
...	...	@@ -2202,181 +1621,2374 @@ Vector256Bool c_ret_vector_256_bool(void) {
2202	1621	false,
2203	1622	};
2204	1623	}
2205
2206		Vector512Bool c_ret_vector_512_bool(void) {
2207		return (Vector512Bool){
2208		false,
2209		true,
2210		false,
2211		false,
2212		false,
2213		true,
2214		false,
2215		false,
2216		false,
2217		true,
2218		false,
2219		false,
2220		false,
2221		true,
2222		false,
2223		true,
2224		false,
2225		false,
2226		false,
2227		false,
2228		false,
2229		false,
2230		true,
2231		true,
2232		false,
2233		false,
2234		false,
2235		false,
2236		true,
2237		true,
2238		false,
2239		true,
2240		false,
2241		true,
2242		true,
2243		true,
2244		false,
2245		false,
2246		true,
2247		true,
2248		false,
2249		false,
2250		false,
2251		false,
2252		false,
2253		true,
2254		false,
2255		true,
2256		true,
2257		false,
2258		true,
2259		true,
2260		true,
2261		true,
2262		false,
2263		false,
2264		false,
2265		true,
2266		true,
2267		false,
2268		false,
2269		false,
2270		false,
2271		true,
2272		true,
2273		true,
2274		true,
2275		true,
2276		false,
2277		false,
2278		false,
2279		false,
2280		false,
2281		true,
2282		false,
2283		true,
2284		false,
2285		false,
2286		true,
2287		true,
2288		false,
2289		false,
2290		false,
2291		true,
2292		false,
2293		true,
2294		true,
2295		true,
2296		false,
2297		true,
2298		false,
2299		false,
2300		true,
2301		true,
2302		false,
2303		true,
2304		true,
2305		false,
2306		true,
2307		false,
2308		true,
2309		true,
2310		false,
2311		true,
2312		true,
2313		false,
2314		false,
2315		false,
2316		true,
2317		false,
2318		false,
2319		false,
2320		true,
2321		true,
2322		true,
2323		false,
2324		true,
2325		false,
2326		true,
2327		false,
2328		true,
2329		true,
2330		false,
2331		true,
2332		false,
2333		true,
2334		true,
2335		true,
2336		false,
2337		true,
2338		false,
2339		false,
2340		false,
2341		false,
2342		false,
2343		false,
2344		true,
2345		false,
2346		true,
2347		false,
2348		true,
2349		true,
2350		false,
2351		true,
2352		false,
2353		false,
2354		true,
2355		false,
2356		false,
2357		true,
2358		false,
	1624	// WASM: The following vector functions define too many Wasm locals for wasmtime in debug mode and are therefore disabled for the wasm target.
	1625	#ifndef __wasm__
	1626	void c_vector_256_bool(Vector_256_bool vec) {
	1627	assert_or_panic(vec[0] == false);
	1628	assert_or_panic(vec[1] == true);
	1629	assert_or_panic(vec[2] == true);
	1630	assert_or_panic(vec[3] == false);
	1631	assert_or_panic(vec[4] == false);
	1632	assert_or_panic(vec[5] == true);
	1633	assert_or_panic(vec[6] == true);
	1634	assert_or_panic(vec[7] == true);
	1635	assert_or_panic(vec[8] == false);
	1636	assert_or_panic(vec[9] == true);
	1637	assert_or_panic(vec[10] == true);
	1638	assert_or_panic(vec[11] == true);
	1639	assert_or_panic(vec[12] == false);
	1640	assert_or_panic(vec[13] == true);
	1641	assert_or_panic(vec[14] == false);
	1642	assert_or_panic(vec[15] == true);
	1643	assert_or_panic(vec[16] == false);
	1644	assert_or_panic(vec[17] == false);
	1645	assert_or_panic(vec[18] == true);
	1646	assert_or_panic(vec[19] == true);
	1647	assert_or_panic(vec[20] == false);
	1648	assert_or_panic(vec[21] == true);
	1649	assert_or_panic(vec[22] == false);
	1650	assert_or_panic(vec[23] == false);
	1651	assert_or_panic(vec[24] == false);
	1652	assert_or_panic(vec[25] == true);
	1653	assert_or_panic(vec[26] == true);
	1654	assert_or_panic(vec[27] == false);
	1655	assert_or_panic(vec[28] == false);
	1656	assert_or_panic(vec[29] == true);
	1657	assert_or_panic(vec[30] == true);
	1658	assert_or_panic(vec[31] == false);
	1659	assert_or_panic(vec[32] == true);
	1660	assert_or_panic(vec[33] == false);
	1661	assert_or_panic(vec[34] == false);
	1662	assert_or_panic(vec[35] == true);
	1663	assert_or_panic(vec[36] == false);
	1664	assert_or_panic(vec[37] == true);
	1665	assert_or_panic(vec[38] == false);
	1666	assert_or_panic(vec[39] == true);
	1667	assert_or_panic(vec[40] == true);
	1668	assert_or_panic(vec[41] == true);
	1669	assert_or_panic(vec[42] == true);
	1670	assert_or_panic(vec[43] == false);
	1671	assert_or_panic(vec[44] == false);
	1672	assert_or_panic(vec[45] == true);
	1673	assert_or_panic(vec[46] == false);
	1674	assert_or_panic(vec[47] == false);
	1675	assert_or_panic(vec[48] == false);
	1676	assert_or_panic(vec[49] == false);
	1677	assert_or_panic(vec[50] == false);
	1678	assert_or_panic(vec[51] == false);
	1679	assert_or_panic(vec[52] == true);
	1680	assert_or_panic(vec[53] == true);
	1681	assert_or_panic(vec[54] == true);
	1682	assert_or_panic(vec[55] == true);
	1683	assert_or_panic(vec[56] == true);
	1684	assert_or_panic(vec[57] == true);
	1685	assert_or_panic(vec[58] == false);
	1686	assert_or_panic(vec[59] == true);
	1687	assert_or_panic(vec[60] == true);
	1688	assert_or_panic(vec[61] == false);
	1689	assert_or_panic(vec[62] == false);
	1690	assert_or_panic(vec[63] == true);
	1691	assert_or_panic(vec[64] == false);
	1692	assert_or_panic(vec[65] == false);
	1693	assert_or_panic(vec[66] == false);
	1694	assert_or_panic(vec[67] == false);
	1695	assert_or_panic(vec[68] == false);
	1696	assert_or_panic(vec[69] == false);
	1697	assert_or_panic(vec[70] == true);
	1698	assert_or_panic(vec[71] == true);
	1699	assert_or_panic(vec[72] == true);
	1700	assert_or_panic(vec[73] == false);
	1701	assert_or_panic(vec[74] == false);
	1702	assert_or_panic(vec[75] == false);
	1703	assert_or_panic(vec[76] == true);
	1704	assert_or_panic(vec[77] == false);
	1705	assert_or_panic(vec[78] == true);
	1706	assert_or_panic(vec[79] == true);
	1707	assert_or_panic(vec[80] == false);
	1708	assert_or_panic(vec[81] == false);
	1709	assert_or_panic(vec[82] == true);
	1710	assert_or_panic(vec[83] == true);
	1711	assert_or_panic(vec[84] == false);
	1712	assert_or_panic(vec[85] == true);
	1713	assert_or_panic(vec[86] == true);
	1714	assert_or_panic(vec[87] == true);
	1715	assert_or_panic(vec[88] == true);
	1716	assert_or_panic(vec[89] == true);
	1717	assert_or_panic(vec[90] == true);
	1718	assert_or_panic(vec[91] == true);
	1719	assert_or_panic(vec[92] == false);
	1720	assert_or_panic(vec[93] == true);
	1721	assert_or_panic(vec[94] == true);
	1722	assert_or_panic(vec[95] == false);
	1723	assert_or_panic(vec[96] == false);
	1724	assert_or_panic(vec[97] == true);
	1725	assert_or_panic(vec[98] == true);
	1726	assert_or_panic(vec[99] == false);
	1727	assert_or_panic(vec[100] == true);
	1728	assert_or_panic(vec[101] == false);
	1729	assert_or_panic(vec[102] == false);
	1730	assert_or_panic(vec[103] == true);
	1731	assert_or_panic(vec[104] == false);
	1732	assert_or_panic(vec[105] == true);
	1733	assert_or_panic(vec[106] == true);
	1734	assert_or_panic(vec[107] == true);
	1735	assert_or_panic(vec[108] == true);
	1736	assert_or_panic(vec[109] == true);
	1737	assert_or_panic(vec[110] == false);
	1738	assert_or_panic(vec[111] == false);
	1739	assert_or_panic(vec[112] == false);
	1740	assert_or_panic(vec[113] == false);
	1741	assert_or_panic(vec[114] == true);
	1742	assert_or_panic(vec[115] == true);
	1743	assert_or_panic(vec[116] == false);
	1744	assert_or_panic(vec[117] == true);
	1745	assert_or_panic(vec[118] == false);
	1746	assert_or_panic(vec[119] == false);
	1747	assert_or_panic(vec[120] == true);
	1748	assert_or_panic(vec[121] == false);
	1749	assert_or_panic(vec[122] == false);
	1750	assert_or_panic(vec[123] == true);
	1751	assert_or_panic(vec[124] == false);
	1752	assert_or_panic(vec[125] == true);
	1753	assert_or_panic(vec[126] == true);
	1754	assert_or_panic(vec[127] == true);
	1755	assert_or_panic(vec[128] == true);
	1756	assert_or_panic(vec[129] == false);
	1757	assert_or_panic(vec[130] == true);
	1758	assert_or_panic(vec[131] == true);
	1759	assert_or_panic(vec[132] == false);
	1760	assert_or_panic(vec[133] == false);
	1761	assert_or_panic(vec[134] == true);
	1762	assert_or_panic(vec[135] == false);
	1763	assert_or_panic(vec[136] == false);
	1764	assert_or_panic(vec[137] == true);
	1765	assert_or_panic(vec[138] == false);
	1766	assert_or_panic(vec[139] == true);
	1767	assert_or_panic(vec[140] == false);
	1768	assert_or_panic(vec[141] == true);
	1769	assert_or_panic(vec[142] == true);
	1770	assert_or_panic(vec[143] == true);
	1771	assert_or_panic(vec[144] == true);
	1772	assert_or_panic(vec[145] == false);
	1773	assert_or_panic(vec[146] == true);
	1774	assert_or_panic(vec[147] == false);
	1775	assert_or_panic(vec[148] == false);
	1776	assert_or_panic(vec[149] == false);
	1777	assert_or_panic(vec[150] == true);
	1778	assert_or_panic(vec[151] == true);
	1779	assert_or_panic(vec[152] == true);
	1780	assert_or_panic(vec[153] == true);
	1781	assert_or_panic(vec[154] == true);
	1782	assert_or_panic(vec[155] == false);
	1783	assert_or_panic(vec[156] == true);
	1784	assert_or_panic(vec[157] == false);
	1785	assert_or_panic(vec[158] == false);
	1786	assert_or_panic(vec[159] == false);
	1787	assert_or_panic(vec[160] == true);
	1788	assert_or_panic(vec[161] == true);
	1789	assert_or_panic(vec[162] == false);
	1790	assert_or_panic(vec[163] == true);
	1791	assert_or_panic(vec[164] == true);
	1792	assert_or_panic(vec[165] == false);
	1793	assert_or_panic(vec[166] == false);
	1794	assert_or_panic(vec[167] == false);
	1795	assert_or_panic(vec[168] == false);
	1796	assert_or_panic(vec[169] == true);
	1797	assert_or_panic(vec[170] == false);
	1798	assert_or_panic(vec[171] == true);
	1799	assert_or_panic(vec[172] == false);
	1800	assert_or_panic(vec[173] == false);
	1801	assert_or_panic(vec[174] == false);
	1802	assert_or_panic(vec[175] == false);
	1803	assert_or_panic(vec[176] == true);
	1804	assert_or_panic(vec[177] == true);
	1805	assert_or_panic(vec[178] == true);
	1806	assert_or_panic(vec[179] == false);
	1807	assert_or_panic(vec[180] == true);
	1808	assert_or_panic(vec[181] == false);
	1809	assert_or_panic(vec[182] == true);
	1810	assert_or_panic(vec[183] == true);
	1811	assert_or_panic(vec[184] == false);
	1812	assert_or_panic(vec[185] == false);
	1813	assert_or_panic(vec[186] == true);
	1814	assert_or_panic(vec[187] == false);
	1815	assert_or_panic(vec[188] == false);
	1816	assert_or_panic(vec[189] == false);
	1817	assert_or_panic(vec[190] == false);
	1818	assert_or_panic(vec[191] == true);
	1819	assert_or_panic(vec[192] == true);
	1820	assert_or_panic(vec[193] == true);
	1821	assert_or_panic(vec[194] == true);
	1822	assert_or_panic(vec[195] == true);
	1823	assert_or_panic(vec[196] == true);
	1824	assert_or_panic(vec[197] == true);
	1825	assert_or_panic(vec[198] == false);
	1826	assert_or_panic(vec[199] == true);
	1827	assert_or_panic(vec[200] == false);
	1828	assert_or_panic(vec[201] == false);
	1829	assert_or_panic(vec[202] == true);
	1830	assert_or_panic(vec[203] == false);
	1831	assert_or_panic(vec[204] == true);
	1832	assert_or_panic(vec[205] == true);
	1833	assert_or_panic(vec[206] == true);
	1834	assert_or_panic(vec[207] == false);
	1835	assert_or_panic(vec[208] == false);
	1836	assert_or_panic(vec[209] == true);
	1837	assert_or_panic(vec[210] == true);
	1838	assert_or_panic(vec[211] == true);
	1839	assert_or_panic(vec[212] == false);
	1840	assert_or_panic(vec[213] == true);
	1841	assert_or_panic(vec[214] == true);
	1842	assert_or_panic(vec[215] == true);
	1843	assert_or_panic(vec[216] == true);
	1844	assert_or_panic(vec[217] == true);
	1845	assert_or_panic(vec[218] == false);
	1846	assert_or_panic(vec[219] == false);
	1847	assert_or_panic(vec[220] == false);
	1848	assert_or_panic(vec[221] == false);
	1849	assert_or_panic(vec[222] == false);
	1850	assert_or_panic(vec[223] == true);
	1851	assert_or_panic(vec[224] == true);
	1852	assert_or_panic(vec[225] == false);
	1853	assert_or_panic(vec[226] == true);
	1854	assert_or_panic(vec[227] == false);
	1855	assert_or_panic(vec[228] == false);
	1856	assert_or_panic(vec[229] == true);
	1857	assert_or_panic(vec[230] == false);
	1858	assert_or_panic(vec[231] == true);
	1859	assert_or_panic(vec[232] == false);
	1860	assert_or_panic(vec[233] == false);
	1861	assert_or_panic(vec[234] == false);
	1862	assert_or_panic(vec[235] == true);
	1863	assert_or_panic(vec[236] == false);
	1864	assert_or_panic(vec[237] == false);
	1865	assert_or_panic(vec[238] == false);
	1866	assert_or_panic(vec[239] == true);
	1867	assert_or_panic(vec[240] == true);
	1868	assert_or_panic(vec[241] == true);
	1869	assert_or_panic(vec[242] == true);
	1870	assert_or_panic(vec[243] == true);
	1871	assert_or_panic(vec[244] == true);
	1872	assert_or_panic(vec[245] == false);
	1873	assert_or_panic(vec[246] == false);
	1874	assert_or_panic(vec[247] == true);
	1875	assert_or_panic(vec[248] == false);
	1876	assert_or_panic(vec[249] == true);
	1877	assert_or_panic(vec[250] == true);
	1878	assert_or_panic(vec[251] == false);
	1879	assert_or_panic(vec[252] == true);
	1880	assert_or_panic(vec[253] == true);
	1881	assert_or_panic(vec[254] == true);
	1882	assert_or_panic(vec[255] == false);
	1883	}
	1884	#endif
	1885	void c_test_vector_256_bool(void) {
	1886	Vector_256_bool vec = zig_ret_vector_256_bool();
	1887	assert_or_panic(vec[0] == true);
	1888	assert_or_panic(vec[1] == true);
	1889	assert_or_panic(vec[2] == true);
	1890	assert_or_panic(vec[3] == false);
	1891	assert_or_panic(vec[4] == true);
	1892	assert_or_panic(vec[5] == false);
	1893	assert_or_panic(vec[6] == false);
	1894	assert_or_panic(vec[7] == true);
	1895	assert_or_panic(vec[8] == false);
	1896	assert_or_panic(vec[9] == false);
	1897	assert_or_panic(vec[10] == false);
	1898	assert_or_panic(vec[11] == false);
	1899	assert_or_panic(vec[12] == false);
	1900	assert_or_panic(vec[13] == false);
	1901	assert_or_panic(vec[14] == false);
	1902	assert_or_panic(vec[15] == false);
	1903	assert_or_panic(vec[16] == true);
	1904	assert_or_panic(vec[17] == false);
	1905	assert_or_panic(vec[18] == true);
	1906	assert_or_panic(vec[19] == false);
	1907	assert_or_panic(vec[20] == false);
	1908	assert_or_panic(vec[21] == true);
	1909	assert_or_panic(vec[22] == true);
	1910	assert_or_panic(vec[23] == false);
	1911	assert_or_panic(vec[24] == false);
	1912	assert_or_panic(vec[25] == true);
	1913	assert_or_panic(vec[26] == true);
	1914	assert_or_panic(vec[27] == false);
	1915	assert_or_panic(vec[28] == true);
	1916	assert_or_panic(vec[29] == true);
	1917	assert_or_panic(vec[30] == true);
	1918	assert_or_panic(vec[31] == false);
	1919	assert_or_panic(vec[32] == true);
	1920	assert_or_panic(vec[33] == false);
	1921	assert_or_panic(vec[34] == true);
	1922	assert_or_panic(vec[35] == false);
	1923	assert_or_panic(vec[36] == true);
	1924	assert_or_panic(vec[37] == false);
	1925	assert_or_panic(vec[38] == true);
	1926	assert_or_panic(vec[39] == false);
	1927	assert_or_panic(vec[40] == false);
	1928	assert_or_panic(vec[41] == false);
	1929	assert_or_panic(vec[42] == true);
	1930	assert_or_panic(vec[43] == true);
	1931	assert_or_panic(vec[44] == true);
	1932	assert_or_panic(vec[45] == false);
	1933	assert_or_panic(vec[46] == false);
	1934	assert_or_panic(vec[47] == false);
	1935	assert_or_panic(vec[48] == true);
	1936	assert_or_panic(vec[49] == false);
	1937	assert_or_panic(vec[50] == true);
	1938	assert_or_panic(vec[51] == false);
	1939	assert_or_panic(vec[52] == true);
	1940	assert_or_panic(vec[53] == false);
	1941	assert_or_panic(vec[54] == true);
	1942	assert_or_panic(vec[55] == true);
	1943	assert_or_panic(vec[56] == false);
	1944	assert_or_panic(vec[57] == false);
	1945	assert_or_panic(vec[58] == false);
	1946	assert_or_panic(vec[59] == true);
	1947	assert_or_panic(vec[60] == true);
	1948	assert_or_panic(vec[61] == true);
	1949	assert_or_panic(vec[62] == false);
	1950	assert_or_panic(vec[63] == true);
	1951	assert_or_panic(vec[64] == false);
	1952	assert_or_panic(vec[65] == true);
	1953	assert_or_panic(vec[66] == false);
	1954	assert_or_panic(vec[67] == true);
	1955	assert_or_panic(vec[68] == true);
	1956	assert_or_panic(vec[69] == false);
	1957	assert_or_panic(vec[70] == true);
	1958	assert_or_panic(vec[71] == false);
	1959	assert_or_panic(vec[72] == true);
	1960	assert_or_panic(vec[73] == true);
	1961	assert_or_panic(vec[74] == false);
	1962	assert_or_panic(vec[75] == false);
	1963	assert_or_panic(vec[76] == false);
	1964	assert_or_panic(vec[77] == false);
	1965	assert_or_panic(vec[78] == false);
	1966	assert_or_panic(vec[79] == false);
	1967	assert_or_panic(vec[80] == false);
	1968	assert_or_panic(vec[81] == false);
	1969	assert_or_panic(vec[82] == false);
	1970	assert_or_panic(vec[83] == true);
	1971	assert_or_panic(vec[84] == false);
	1972	assert_or_panic(vec[85] == false);
	1973	assert_or_panic(vec[86] == false);
	1974	assert_or_panic(vec[87] == true);
	1975	assert_or_panic(vec[88] == false);
	1976	assert_or_panic(vec[89] == true);
	1977	assert_or_panic(vec[90] == true);
	1978	assert_or_panic(vec[91] == false);
	1979	assert_or_panic(vec[92] == false);
	1980	assert_or_panic(vec[93] == true);
	1981	assert_or_panic(vec[94] == true);
	1982	assert_or_panic(vec[95] == false);
	1983	assert_or_panic(vec[96] == false);
	1984	assert_or_panic(vec[97] == true);
	1985	assert_or_panic(vec[98] == false);
	1986	assert_or_panic(vec[99] == false);
	1987	assert_or_panic(vec[100] == false);
	1988	assert_or_panic(vec[101] == false);
	1989	assert_or_panic(vec[102] == false);
	1990	assert_or_panic(vec[103] == false);
	1991	assert_or_panic(vec[104] == false);
	1992	assert_or_panic(vec[105] == true);
	1993	assert_or_panic(vec[106] == true);
	1994	assert_or_panic(vec[107] == false);
	1995	assert_or_panic(vec[108] == true);
	1996	assert_or_panic(vec[109] == false);
	1997	assert_or_panic(vec[110] == true);
	1998	assert_or_panic(vec[111] == true);
	1999	assert_or_panic(vec[112] == false);
	2000	assert_or_panic(vec[113] == false);
	2001	assert_or_panic(vec[114] == false);
	2002	assert_or_panic(vec[115] == false);
	2003	assert_or_panic(vec[116] == false);
	2004	assert_or_panic(vec[117] == false);
	2005	assert_or_panic(vec[118] == false);
	2006	assert_or_panic(vec[119] == true);
	2007	assert_or_panic(vec[120] == true);
	2008	assert_or_panic(vec[121] == true);
	2009	assert_or_panic(vec[122] == false);
	2010	assert_or_panic(vec[123] == true);
	2011	assert_or_panic(vec[124] == true);
	2012	assert_or_panic(vec[125] == false);
	2013	assert_or_panic(vec[126] == false);
	2014	assert_or_panic(vec[127] == true);
	2015	assert_or_panic(vec[128] == true);
	2016	assert_or_panic(vec[129] == true);
	2017	assert_or_panic(vec[130] == true);
	2018	assert_or_panic(vec[131] == true);
	2019	assert_or_panic(vec[132] == false);
	2020	assert_or_panic(vec[133] == true);
	2021	assert_or_panic(vec[134] == true);
	2022	assert_or_panic(vec[135] == false);
	2023	assert_or_panic(vec[136] == false);
	2024	assert_or_panic(vec[137] == true);
	2025	assert_or_panic(vec[138] == true);
	2026	assert_or_panic(vec[139] == false);
	2027	assert_or_panic(vec[140] == true);
	2028	assert_or_panic(vec[141] == false);
	2029	assert_or_panic(vec[142] == true);
	2030	assert_or_panic(vec[143] == false);
	2031	assert_or_panic(vec[144] == true);
	2032	assert_or_panic(vec[145] == true);
	2033	assert_or_panic(vec[146] == true);
	2034	assert_or_panic(vec[147] == true);
	2035	assert_or_panic(vec[148] == false);
	2036	assert_or_panic(vec[149] == false);
	2037	assert_or_panic(vec[150] == false);
	2038	assert_or_panic(vec[151] == true);
	2039	assert_or_panic(vec[152] == false);
	2040	assert_or_panic(vec[153] == true);
	2041	assert_or_panic(vec[154] == false);
	2042	assert_or_panic(vec[155] == true);
	2043	assert_or_panic(vec[156] == true);
	2044	assert_or_panic(vec[157] == false);
	2045	assert_or_panic(vec[158] == true);
	2046	assert_or_panic(vec[159] == true);
	2047	assert_or_panic(vec[160] == true);
	2048	assert_or_panic(vec[161] == true);
	2049	assert_or_panic(vec[162] == true);
	2050	assert_or_panic(vec[163] == false);
	2051	assert_or_panic(vec[164] == false);
	2052	assert_or_panic(vec[165] == true);
	2053	assert_or_panic(vec[166] == false);
	2054	assert_or_panic(vec[167] == true);
	2055	assert_or_panic(vec[168] == true);
	2056	assert_or_panic(vec[169] == true);
	2057	assert_or_panic(vec[170] == true);
	2058	assert_or_panic(vec[171] == false);
	2059	assert_or_panic(vec[172] == true);
	2060	assert_or_panic(vec[173] == true);
	2061	assert_or_panic(vec[174] == true);
	2062	assert_or_panic(vec[175] == true);
	2063	assert_or_panic(vec[176] == true);
	2064	assert_or_panic(vec[177] == true);
	2065	assert_or_panic(vec[178] == true);
	2066	assert_or_panic(vec[179] == false);
	2067	assert_or_panic(vec[180] == true);
	2068	assert_or_panic(vec[181] == false);
	2069	assert_or_panic(vec[182] == false);
	2070	assert_or_panic(vec[183] == false);
	2071	assert_or_panic(vec[184] == true);
	2072	assert_or_panic(vec[185] == false);
	2073	assert_or_panic(vec[186] == true);
	2074	assert_or_panic(vec[187] == true);
	2075	assert_or_panic(vec[188] == false);
	2076	assert_or_panic(vec[189] == true);
	2077	assert_or_panic(vec[190] == false);
	2078	assert_or_panic(vec[191] == true);
	2079	assert_or_panic(vec[192] == false);
	2080	assert_or_panic(vec[193] == true);
	2081	assert_or_panic(vec[194] == false);
	2082	assert_or_panic(vec[195] == false);
	2083	assert_or_panic(vec[196] == true);
	2084	assert_or_panic(vec[197] == true);
	2085	assert_or_panic(vec[198] == true);
	2086	assert_or_panic(vec[199] == true);
	2087	assert_or_panic(vec[200] == true);
	2088	assert_or_panic(vec[201] == true);
	2089	assert_or_panic(vec[202] == true);
	2090	assert_or_panic(vec[203] == false);
	2091	assert_or_panic(vec[204] == true);
	2092	assert_or_panic(vec[205] == false);
	2093	assert_or_panic(vec[206] == false);
	2094	assert_or_panic(vec[207] == true);
	2095	assert_or_panic(vec[208] == true);
	2096	assert_or_panic(vec[209] == false);
	2097	assert_or_panic(vec[210] == false);
	2098	assert_or_panic(vec[211] == false);
	2099	assert_or_panic(vec[212] == true);
	2100	assert_or_panic(vec[213] == true);
	2101	assert_or_panic(vec[214] == true);
	2102	assert_or_panic(vec[215] == false);
	2103	assert_or_panic(vec[216] == false);
	2104	assert_or_panic(vec[217] == true);
	2105	assert_or_panic(vec[218] == true);
	2106	assert_or_panic(vec[219] == true);
	2107	assert_or_panic(vec[220] == true);
	2108	assert_or_panic(vec[221] == false);
	2109	assert_or_panic(vec[222] == true);
	2110	assert_or_panic(vec[223] == false);
	2111	assert_or_panic(vec[224] == true);
	2112	assert_or_panic(vec[225] == true);
	2113	assert_or_panic(vec[226] == true);
	2114	assert_or_panic(vec[227] == false);
	2115	assert_or_panic(vec[228] == false);
	2116	assert_or_panic(vec[229] == false);
	2117	assert_or_panic(vec[230] == false);
	2118	assert_or_panic(vec[231] == false);
	2119	assert_or_panic(vec[232] == true);
	2120	assert_or_panic(vec[233] == true);
	2121	assert_or_panic(vec[234] == false);
	2122	assert_or_panic(vec[235] == false);
	2123	assert_or_panic(vec[236] == false);
	2124	assert_or_panic(vec[237] == true);
	2125	assert_or_panic(vec[238] == true);
	2126	assert_or_panic(vec[239] == false);
	2127	assert_or_panic(vec[240] == true);
	2128	assert_or_panic(vec[241] == true);
	2129	assert_or_panic(vec[242] == true);
	2130	assert_or_panic(vec[243] == false);
	2131	assert_or_panic(vec[244] == true);
	2132	assert_or_panic(vec[245] == true);
	2133	assert_or_panic(vec[246] == false);
	2134	assert_or_panic(vec[247] == true);
	2135	assert_or_panic(vec[248] == false);
	2136	assert_or_panic(vec[249] == false);
	2137	assert_or_panic(vec[250] == true);
	2138	assert_or_panic(vec[251] == true);
	2139	assert_or_panic(vec[252] == false);
	2140	assert_or_panic(vec[253] == true);
	2141	assert_or_panic(vec[254] == false);
	2142	assert_or_panic(vec[255] == true);
	2143	zig_vector_256_bool((Vector_256_bool){
	2144	false,
	2145	false,
	2146	false,
	2147	false,
	2148	true,
	2149	true,
	2150	false,
	2151	false,
	2152	false,
	2153	true,
	2154	true,
	2155	false,
	2156	true,
	2157	false,
	2158	false,
	2159	false,
	2160	false,
	2161	true,
	2162	true,
	2163	true,
	2164	false,
	2165	true,
	2166	true,
	2167	false,
	2168	true,
	2169	false,
	2170	false,
	2171	true,
	2172	true,
	2173	true,
	2174	false,
	2175	true,
	2176	false,
	2177	true,
	2178	false,
	2179	false,
	2180	false,
	2181	true,
	2182	false,
	2183	false,
	2184	true,
	2185	true,
	2186	false,
	2187	true,
	2188	true,
	2189	false,
	2190	true,
	2191	false,
	2192	true,
	2193	false,
	2194	true,
	2195	false,
	2196	true,
	2197	true,
	2198	true,
	2199	false,
	2200	false,
	2201	true,
	2202	true,
	2203	false,
	2204	false,
	2205	true,
	2206	true,
	2207	false,
	2208	false,
	2209	false,
	2210	true,
	2211	true,
	2212	false,
	2213	true,
	2214	false,
	2215	true,
	2216	false,
	2217	true,
	2218	false,
	2219	false,
	2220	true,
	2221	false,
	2222	false,
	2223	false,
	2224	false,
	2225	false,
	2226	true,
	2227	false,
	2228	false,
	2229	false,
	2230	true,
	2231	true,
	2232	true,
	2233	false,
	2234	true,
	2235	false,
	2236	true,
	2237	false,
	2238	true,
	2239	true,
	2240	true,
	2241	true,
	2242	false,
	2243	true,
	2244	false,
	2245	true,
	2246	true,
	2247	false,
	2248	false,
	2249	true,
	2250	false,
	2251	true,
	2252	false,
	2253	false,
	2254	false,
	2255	false,
	2256	false,
	2257	false,
	2258	false,
	2259	false,
	2260	false,
	2261	false,
	2262	false,
	2263	false,
	2264	false,
	2265	false,
	2266	true,
	2267	true,
	2268	false,
	2269	false,
	2270	false,
	2271	true,
	2272	true,
	2273	true,
	2274	true,
	2275	false,
	2276	false,
	2277	false,
	2278	true,
	2279	true,
	2280	false,
	2281	false,
	2282	true,
	2283	true,
	2284	true,
	2285	true,
	2286	true,
	2287	false,
	2288	true,
	2289	true,
	2290	true,
	2291	false,
	2292	false,
	2293	false,
	2294	false,
	2295	false,
	2296	false,
	2297	false,
	2298	true,
	2299	false,
	2300	false,
	2301	false,
	2302	true,
	2303	true,
	2304	false,
	2305	true,
	2306	false,
	2307	false,
	2308	false,
	2309	true,
	2310	false,
	2311	true,
	2312	false,
	2313	false,
	2314	false,
	2315	false,
	2316	true,
	2317	true,
	2318	true,
	2319	true,
	2320	true,
	2321	true,
	2322	false,
	2323	true,
	2324	true,
	2325	false,
	2326	true,
	2327	false,
	2328	true,
	2329	false,
	2330	true,
	2331	false,
	2332	true,
	2333	false,
	2334	false,
	2335	false,
	2336	false,
	2337	true,
	2338	true,
	2339	true,
	2340	false,
	2341	false,
	2342	true,
	2343	false,
	2344	false,
	2345	true,
	2346	true,
	2347	false,
	2348	true,
	2349	false,
	2350	true,
	2351	false,
	2352	false,
	2353	false,
	2354	true,
	2355	true,
	2356	false,
	2357	false,
	2358	false,
	2359	true,
	2360	false,
	2361	true,
	2362	true,
	2363	true,
	2364	false,
	2365	true,
	2366	false,
	2367	true,
	2368	false,
	2369	false,
	2370	false,
	2371	true,
	2372	true,
	2373	false,
	2374	false,
	2375	false,
	2376	false,
	2377	false,
	2378	true,
	2379	false,
	2380	false,
	2381	false,
	2382	true,
	2383	false,
	2384	true,
	2385	true,
	2386	true,
	2387	false,
	2388	false,
	2389	true,
	2390	false,
	2391	false,
	2392	false,
	2393	true,
	2394	false,
	2395	false,
	2396	true,
	2397	true,
	2398	true,
	2399	true,
	2400	});
	2401	}
	2402
	2403	typedef bool Vector_512_bool __attribute__((ext_vector_type(512)));
	2404
	2405	Vector_512_bool zig_ret_vector_512_bool(void);
	2406	void zig_vector_512_bool(Vector_512_bool vec);
	2407
	2408	Vector_512_bool c_ret_vector_512_bool(void) {
	2409	return (Vector_512_bool){
	2410	false,
	2411	true,
	2412	false,
	2413	false,
	2414	false,
	2415	true,
	2416	false,
	2417	false,
	2418	false,
	2419	true,
	2420	false,
	2421	false,
	2422	false,
	2423	true,
	2424	false,
	2425	true,
	2426	false,
	2427	false,
	2428	false,
	2429	false,
	2430	false,
	2431	false,
	2432	true,
	2433	true,
	2434	false,
	2435	false,
	2436	false,
	2437	false,
	2438	true,
	2439	true,
	2440	false,
	2441	true,
	2442	false,
	2443	true,
	2444	true,
	2445	true,
	2446	false,
	2447	false,
	2448	true,
	2449	true,
	2450	false,
	2451	false,
	2452	false,
	2453	false,
	2454	false,
	2455	true,
	2456	false,
	2457	true,
	2458	true,
	2459	false,
	2460	true,
	2461	true,
	2462	true,
	2463	true,
	2464	false,
	2465	false,
	2466	false,
	2467	true,
	2468	true,
	2469	false,
	2470	false,
	2471	false,
	2472	false,
	2473	true,
	2474	true,
	2475	true,
	2476	true,
	2477	true,
	2478	false,
	2479	false,
	2480	false,
	2481	false,
	2482	false,
	2483	true,
	2484	false,
	2485	true,
	2486	false,
	2487	false,
	2488	true,
	2489	true,
	2490	false,
	2491	false,
	2492	false,
	2493	true,
	2494	false,
	2495	true,
	2496	true,
	2497	true,
	2498	false,
	2499	true,
	2500	false,
	2501	false,
	2502	true,
	2503	true,
	2504	false,
	2505	true,
	2506	true,
	2507	false,
	2508	true,
	2509	false,
	2510	true,
	2511	true,
	2512	false,
	2513	true,
	2514	true,
	2515	false,
	2516	false,
	2517	false,
	2518	true,
	2519	false,
	2520	false,
	2521	false,
	2522	true,
	2523	true,
	2524	true,
	2525	false,
	2526	true,
	2527	false,
	2528	true,
	2529	false,
	2530	true,
	2531	true,
	2532	false,
	2533	true,
	2534	false,
	2535	true,
	2536	true,
	2537	true,
	2538	false,
	2539	true,
	2540	false,
	2541	false,
	2542	false,
	2543	false,
	2544	false,
	2545	false,
	2546	true,
	2547	false,
	2548	true,
	2549	false,
	2550	true,
	2551	true,
	2552	false,
	2553	true,
	2554	false,
	2555	false,
	2556	true,
	2557	false,
	2558	false,
	2559	true,
	2560	false,
	2561	true,
	2562	false,
	2563	true,
	2564	false,
	2565	false,
	2566	true,
	2567	false,
	2568	true,
	2569	true,
	2570	true,
	2571	false,
	2572	false,
	2573	true,
	2574	false,
	2575	false,
	2576	false,
	2577	true,
	2578	true,
	2579	true,
	2580	false,
	2581	true,
	2582	false,
	2583	false,
	2584	false,
	2585	false,
	2586	false,
	2587	true,
	2588	true,
	2589	false,
	2590	false,
	2591	true,
	2592	false,
	2593	false,
	2594	false,
	2595	false,
	2596	false,
	2597	true,
	2598	true,
	2599	false,
	2600	false,
	2601	false,
	2602	false,
	2603	false,
	2604	false,
	2605	true,
	2606	true,
	2607	false,
	2608	true,
	2609	true,
	2610	true,
	2611	true,
	2612	true,
	2613	true,
	2614	false,
	2615	false,
	2616	false,
	2617	false,
	2618	true,
	2619	false,
	2620	true,
	2621	true,
	2622	true,
	2623	true,
	2624	false,
	2625	false,
	2626	false,
	2627	true,
	2628	true,
	2629	false,
	2630	true,
	2631	true,
	2632	false,
	2633	false,
	2634	false,
	2635	true,
	2636	true,
	2637	true,
	2638	true,
	2639	false,
	2640	true,
	2641	false,
	2642	true,
	2643	true,
	2644	true,
	2645	true,
	2646	false,
	2647	true,
	2648	false,
	2649	true,
	2650	false,
	2651	true,
	2652	false,
	2653	false,
	2654	false,
	2655	true,
	2656	true,
	2657	false,
	2658	true,
	2659	false,
	2660	false,
	2661	false,
	2662	true,
	2663	true,
	2664	true,
	2665	true,
	2666	true,
	2667	false,
	2668	true,
	2669	true,
	2670	true,
	2671	true,
	2672	false,
	2673	true,
	2674	false,
	2675	false,
	2676	true,
	2677	false,
	2678	true,
	2679	false,
	2680	false,
	2681	true,
	2682	true,
	2683	false,
	2684	true,
	2685	false,
	2686	false,
	2687	true,
	2688	false,
	2689	false,
	2690	true,
	2691	true,
	2692	true,
	2693	false,
	2694	false,
	2695	true,
	2696	true,
	2697	true,
	2698	false,
	2699	false,
	2700	false,
	2701	false,
	2702	false,
	2703	false,
	2704	true,
	2705	false,
	2706	true,
	2707	false,
	2708	true,
	2709	true,
	2710	false,
	2711	false,
	2712	false,
	2713	false,
	2714	true,
	2715	true,
	2716	true,
	2717	true,
	2718	true,
	2719	false,
	2720	true,
	2721	true,
	2722	true,
	2723	true,
	2724	true,
	2725	false,
	2726	true,
	2727	true,
	2728	true,
	2729	false,
	2730	true,
	2731	false,
	2732	true,
	2733	true,
	2734	true,
	2735	false,
	2736	false,
	2737	true,
	2738	true,
	2739	true,
	2740	false,
	2741	false,
	2742	true,
	2743	true,
	2744	false,
	2745	true,
	2746	true,
	2747	true,
	2748	true,
	2749	true,
	2750	true,
	2751	false,
	2752	true,
	2753	false,
	2754	true,
	2755	false,
	2756	false,
	2757	false,
	2758	false,
	2759	true,
	2760	true,
	2761	true,
	2762	true,
	2763	false,
	2764	true,
	2765	false,
	2766	true,
	2767	true,
	2768	false,
	2769	true,
	2770	false,
	2771	false,
	2772	true,
	2773	false,
	2774	false,
	2775	false,
	2776	false,
	2777	false,
	2778	false,
	2779	false,
	2780	true,
	2781	false,
	2782	true,
	2783	true,
	2784	false,
	2785	false,
	2786	true,
	2787	false,
	2788	false,
	2789	true,
	2790	false,
	2791	false,
	2792	true,
	2793	false,
	2794	false,
	2795	false,
	2796	false,
	2797	true,
	2798	true,
	2799	true,
	2800	true,
	2801	true,
	2802	true,
	2803	true,
	2804	false,
	2805	true,
	2806	true,
	2807	false,
	2808	false,
	2809	false,
	2810	true,
	2811	false,
	2812	true,
	2813	true,
	2814	false,
	2815	true,
	2816	true,
	2817	true,
	2818	true,
	2819	false,
	2820	false,
	2821	false,
	2822	true,
	2823	true,
	2824	false,
	2825	true,
	2826	false,
	2827	true,
	2828	false,
	2829	false,
	2830	false,
	2831	false,
	2832	true,
	2833	true,
	2834	true,
	2835	false,
	2836	true,
	2837	false,
	2838	false,
	2839	false,
	2840	true,
	2841	true,
	2842	false,
	2843	true,
	2844	false,
	2845	false,
	2846	true,
	2847	true,
	2848	true,
	2849	true,
	2850	true,
	2851	true,
	2852	false,
	2853	false,
	2854	false,
	2855	true,
	2856	true,
	2857	true,
	2858	false,
	2859	false,
	2860	false,
	2861	false,
	2862	false,
	2863	false,
	2864	false,
	2865	false,
	2866	false,
	2867	false,
	2868	false,
	2869	true,
	2870	false,
	2871	false,
	2872	false,
	2873	true,
	2874	false,
	2875	false,
	2876	false,
	2877	false,
	2878	true,
	2879	true,
	2880	true,
	2881	true,
	2882	true,
	2883	false,
	2884	false,
	2885	true,
	2886	true,
	2887	true,
	2888	false,
	2889	true,
	2890	true,
	2891	true,
	2892	false,
	2893	true,
	2894	false,
	2895	true,
	2896	false,
	2897	true,
	2898	false,
	2899	true,
	2900	true,
2359	2901	true,
	2902	true,
	2903	false,
	2904	true,
	2905	true,
	2906	false,
	2907	true,
	2908	false,
	2909	false,
	2910	false,
	2911	false,
	2912	false,
	2913	false,
	2914	false,
	2915	false,
	2916	false,
	2917	true,
	2918	true,
	2919	false,
	2920	true,
	2921	false,
	2922	};
	2923	}
	2924	// WASM: The following vector functions define too many Wasm locals for wasmtime in debug mode and are therefore disabled for the wasm target.
	2925	#ifndef __wasm__
	2926	void c_vector_512_bool(Vector_512_bool vec) {
	2927	assert_or_panic(vec[0] == true);
	2928	assert_or_panic(vec[1] == true);
	2929	assert_or_panic(vec[2] == true);
	2930	assert_or_panic(vec[3] == true);
	2931	assert_or_panic(vec[4] == true);
	2932	assert_or_panic(vec[5] == false);
	2933	assert_or_panic(vec[6] == false);
	2934	assert_or_panic(vec[7] == true);
	2935	assert_or_panic(vec[8] == true);
	2936	assert_or_panic(vec[9] == true);
	2937	assert_or_panic(vec[10] == true);
	2938	assert_or_panic(vec[11] == false);
	2939	assert_or_panic(vec[12] == true);
	2940	assert_or_panic(vec[13] == true);
	2941	assert_or_panic(vec[14] == false);
	2942	assert_or_panic(vec[15] == false);
	2943	assert_or_panic(vec[16] == false);
	2944	assert_or_panic(vec[17] == true);
	2945	assert_or_panic(vec[18] == true);
	2946	assert_or_panic(vec[19] == true);
	2947	assert_or_panic(vec[20] == true);
	2948	assert_or_panic(vec[21] == true);
	2949	assert_or_panic(vec[22] == false);
	2950	assert_or_panic(vec[23] == false);
	2951	assert_or_panic(vec[24] == true);
	2952	assert_or_panic(vec[25] == true);
	2953	assert_or_panic(vec[26] == false);
	2954	assert_or_panic(vec[27] == false);
	2955	assert_or_panic(vec[28] == false);
	2956	assert_or_panic(vec[29] == false);
	2957	assert_or_panic(vec[30] == false);
	2958	assert_or_panic(vec[31] == true);
	2959	assert_or_panic(vec[32] == true);
	2960	assert_or_panic(vec[33] == false);
	2961	assert_or_panic(vec[34] == true);
	2962	assert_or_panic(vec[35] == true);
	2963	assert_or_panic(vec[36] == true);
	2964	assert_or_panic(vec[37] == true);
	2965	assert_or_panic(vec[38] == true);
	2966	assert_or_panic(vec[39] == true);
	2967	assert_or_panic(vec[40] == false);
	2968	assert_or_panic(vec[41] == true);
	2969	assert_or_panic(vec[42] == true);
	2970	assert_or_panic(vec[43] == false);
	2971	assert_or_panic(vec[44] == false);
	2972	assert_or_panic(vec[45] == false);
	2973	assert_or_panic(vec[46] == true);
	2974	assert_or_panic(vec[47] == true);
	2975	assert_or_panic(vec[48] == false);
	2976	assert_or_panic(vec[49] == true);
	2977	assert_or_panic(vec[50] == false);
	2978	assert_or_panic(vec[51] == true);
	2979	assert_or_panic(vec[52] == true);
	2980	assert_or_panic(vec[53] == false);
	2981	assert_or_panic(vec[54] == true);
	2982	assert_or_panic(vec[55] == false);
	2983	assert_or_panic(vec[56] == false);
	2984	assert_or_panic(vec[57] == true);
	2985	assert_or_panic(vec[58] == true);
	2986	assert_or_panic(vec[59] == false);
	2987	assert_or_panic(vec[60] == true);
	2988	assert_or_panic(vec[61] == true);
	2989	assert_or_panic(vec[62] == false);
	2990	assert_or_panic(vec[63] == true);
	2991	assert_or_panic(vec[64] == false);
	2992	assert_or_panic(vec[65] == true);
	2993	assert_or_panic(vec[66] == true);
	2994	assert_or_panic(vec[67] == true);
	2995	assert_or_panic(vec[68] == true);
	2996	assert_or_panic(vec[69] == true);
	2997	assert_or_panic(vec[70] == true);
	2998	assert_or_panic(vec[71] == true);
	2999	assert_or_panic(vec[72] == true);
	3000	assert_or_panic(vec[73] == true);
	3001	assert_or_panic(vec[74] == false);
	3002	assert_or_panic(vec[75] == true);
	3003	assert_or_panic(vec[76] == false);
	3004	assert_or_panic(vec[77] == true);
	3005	assert_or_panic(vec[78] == false);
	3006	assert_or_panic(vec[79] == false);
	3007	assert_or_panic(vec[80] == false);
	3008	assert_or_panic(vec[81] == true);
	3009	assert_or_panic(vec[82] == false);
	3010	assert_or_panic(vec[83] == true);
	3011	assert_or_panic(vec[84] == true);
	3012	assert_or_panic(vec[85] == false);
	3013	assert_or_panic(vec[86] == true);
	3014	assert_or_panic(vec[87] == true);
	3015	assert_or_panic(vec[88] == true);
	3016	assert_or_panic(vec[89] == false);
	3017	assert_or_panic(vec[90] == true);
	3018	assert_or_panic(vec[91] == true);
	3019	assert_or_panic(vec[92] == false);
	3020	assert_or_panic(vec[93] == true);
	3021	assert_or_panic(vec[94] == false);
	3022	assert_or_panic(vec[95] == true);
	3023	assert_or_panic(vec[96] == true);
	3024	assert_or_panic(vec[97] == false);
	3025	assert_or_panic(vec[98] == false);
	3026	assert_or_panic(vec[99] == false);
	3027	assert_or_panic(vec[100] == true);
	3028	assert_or_panic(vec[101] == true);
	3029	assert_or_panic(vec[102] == false);
	3030	assert_or_panic(vec[103] == true);
	3031	assert_or_panic(vec[104] == false);
	3032	assert_or_panic(vec[105] == false);
	3033	assert_or_panic(vec[106] == true);
	3034	assert_or_panic(vec[107] == false);
	3035	assert_or_panic(vec[108] == false);
	3036	assert_or_panic(vec[109] == true);
	3037	assert_or_panic(vec[110] == false);
	3038	assert_or_panic(vec[111] == false);
	3039	assert_or_panic(vec[112] == false);
	3040	assert_or_panic(vec[113] == false);
	3041	assert_or_panic(vec[114] == false);
	3042	assert_or_panic(vec[115] == true);
	3043	assert_or_panic(vec[116] == true);
	3044	assert_or_panic(vec[117] == false);
	3045	assert_or_panic(vec[118] == false);
	3046	assert_or_panic(vec[119] == false);
	3047	assert_or_panic(vec[120] == false);
	3048	assert_or_panic(vec[121] == true);
	3049	assert_or_panic(vec[122] == false);
	3050	assert_or_panic(vec[123] == false);
	3051	assert_or_panic(vec[124] == true);
	3052	assert_or_panic(vec[125] == true);
	3053	assert_or_panic(vec[126] == false);
	3054	assert_or_panic(vec[127] == true);
	3055	assert_or_panic(vec[128] == false);
	3056	assert_or_panic(vec[129] == true);
	3057	assert_or_panic(vec[130] == true);
	3058	assert_or_panic(vec[131] == false);
	3059	assert_or_panic(vec[132] == true);
	3060	assert_or_panic(vec[133] == false);
	3061	assert_or_panic(vec[134] == false);
	3062	assert_or_panic(vec[135] == false);
	3063	assert_or_panic(vec[136] == false);
	3064	assert_or_panic(vec[137] == true);
	3065	assert_or_panic(vec[138] == true);
	3066	assert_or_panic(vec[139] == false);
	3067	assert_or_panic(vec[140] == false);
	3068	assert_or_panic(vec[141] == false);
	3069	assert_or_panic(vec[142] == true);
	3070	assert_or_panic(vec[143] == true);
	3071	assert_or_panic(vec[144] == false);
	3072	assert_or_panic(vec[145] == false);
	3073	assert_or_panic(vec[146] == true);
	3074	assert_or_panic(vec[147] == true);
	3075	assert_or_panic(vec[148] == true);
	3076	assert_or_panic(vec[149] == true);
	3077	assert_or_panic(vec[150] == true);
	3078	assert_or_panic(vec[151] == true);
	3079	assert_or_panic(vec[152] == true);
	3080	assert_or_panic(vec[153] == false);
	3081	assert_or_panic(vec[154] == true);
	3082	assert_or_panic(vec[155] == false);
	3083	assert_or_panic(vec[156] == false);
	3084	assert_or_panic(vec[157] == true);
	3085	assert_or_panic(vec[158] == false);
	3086	assert_or_panic(vec[159] == true);
	3087	assert_or_panic(vec[160] == false);
	3088	assert_or_panic(vec[161] == true);
	3089	assert_or_panic(vec[162] == true);
	3090	assert_or_panic(vec[163] == true);
	3091	assert_or_panic(vec[164] == true);
	3092	assert_or_panic(vec[165] == true);
	3093	assert_or_panic(vec[166] == true);
	3094	assert_or_panic(vec[167] == true);
	3095	assert_or_panic(vec[168] == true);
	3096	assert_or_panic(vec[169] == false);
	3097	assert_or_panic(vec[170] == true);
	3098	assert_or_panic(vec[171] == true);
	3099	assert_or_panic(vec[172] == false);
	3100	assert_or_panic(vec[173] == true);
	3101	assert_or_panic(vec[174] == true);
	3102	assert_or_panic(vec[175] == false);
	3103	assert_or_panic(vec[176] == false);
	3104	assert_or_panic(vec[177] == false);
	3105	assert_or_panic(vec[178] == true);
	3106	assert_or_panic(vec[179] == false);
	3107	assert_or_panic(vec[180] == false);
	3108	assert_or_panic(vec[181] == true);
	3109	assert_or_panic(vec[182] == true);
	3110	assert_or_panic(vec[183] == true);
	3111	assert_or_panic(vec[184] == true);
	3112	assert_or_panic(vec[185] == true);
	3113	assert_or_panic(vec[186] == true);
	3114	assert_or_panic(vec[187] == true);
	3115	assert_or_panic(vec[188] == true);
	3116	assert_or_panic(vec[189] == true);
	3117	assert_or_panic(vec[190] == false);
	3118	assert_or_panic(vec[191] == true);
	3119	assert_or_panic(vec[192] == true);
	3120	assert_or_panic(vec[193] == false);
	3121	assert_or_panic(vec[194] == false);
	3122	assert_or_panic(vec[195] == true);
	3123	assert_or_panic(vec[196] == true);
	3124	assert_or_panic(vec[197] == false);
	3125	assert_or_panic(vec[198] == true);
	3126	assert_or_panic(vec[199] == true);
	3127	assert_or_panic(vec[200] == false);
	3128	assert_or_panic(vec[201] == true);
	3129	assert_or_panic(vec[202] == true);
	3130	assert_or_panic(vec[203] == false);
	3131	assert_or_panic(vec[204] == true);
	3132	assert_or_panic(vec[205] == true);
	3133	assert_or_panic(vec[206] == true);
	3134	assert_or_panic(vec[207] == true);
	3135	assert_or_panic(vec[208] == false);
	3136	assert_or_panic(vec[209] == true);
	3137	assert_or_panic(vec[210] == false);
	3138	assert_or_panic(vec[211] == true);
	3139	assert_or_panic(vec[212] == true);
	3140	assert_or_panic(vec[213] == false);
	3141	assert_or_panic(vec[214] == true);
	3142	assert_or_panic(vec[215] == false);
	3143	assert_or_panic(vec[216] == true);
	3144	assert_or_panic(vec[217] == false);
	3145	assert_or_panic(vec[218] == true);
	3146	assert_or_panic(vec[219] == false);
	3147	assert_or_panic(vec[220] == false);
	3148	assert_or_panic(vec[221] == true);
	3149	assert_or_panic(vec[222] == false);
	3150	assert_or_panic(vec[223] == false);
	3151	assert_or_panic(vec[224] == false);
	3152	assert_or_panic(vec[225] == true);
	3153	assert_or_panic(vec[226] == true);
	3154	assert_or_panic(vec[227] == false);
	3155	assert_or_panic(vec[228] == false);
	3156	assert_or_panic(vec[229] == false);
	3157	assert_or_panic(vec[230] == true);
	3158	assert_or_panic(vec[231] == false);
	3159	assert_or_panic(vec[232] == true);
	3160	assert_or_panic(vec[233] == false);
	3161	assert_or_panic(vec[234] == false);
	3162	assert_or_panic(vec[235] == false);
	3163	assert_or_panic(vec[236] == true);
	3164	assert_or_panic(vec[237] == true);
	3165	assert_or_panic(vec[238] == false);
	3166	assert_or_panic(vec[239] == false);
	3167	assert_or_panic(vec[240] == false);
	3168	assert_or_panic(vec[241] == false);
	3169	assert_or_panic(vec[242] == false);
	3170	assert_or_panic(vec[243] == true);
	3171	assert_or_panic(vec[244] == true);
	3172	assert_or_panic(vec[245] == false);
	3173	assert_or_panic(vec[246] == true);
	3174	assert_or_panic(vec[247] == false);
	3175	assert_or_panic(vec[248] == false);
	3176	assert_or_panic(vec[249] == true);
	3177	assert_or_panic(vec[250] == false);
	3178	assert_or_panic(vec[251] == false);
	3179	assert_or_panic(vec[252] == false);
	3180	assert_or_panic(vec[253] == true);
	3181	assert_or_panic(vec[254] == false);
	3182	assert_or_panic(vec[255] == false);
	3183	assert_or_panic(vec[256] == false);
	3184	assert_or_panic(vec[257] == false);
	3185	assert_or_panic(vec[258] == true);
	3186	assert_or_panic(vec[259] == true);
	3187	assert_or_panic(vec[260] == true);
	3188	assert_or_panic(vec[261] == true);
	3189	assert_or_panic(vec[262] == false);
	3190	assert_or_panic(vec[263] == true);
	3191	assert_or_panic(vec[264] == false);
	3192	assert_or_panic(vec[265] == false);
	3193	assert_or_panic(vec[266] == false);
	3194	assert_or_panic(vec[267] == true);
	3195	assert_or_panic(vec[268] == false);
	3196	assert_or_panic(vec[269] == false);
	3197	assert_or_panic(vec[270] == true);
	3198	assert_or_panic(vec[271] == true);
	3199	assert_or_panic(vec[272] == false);
	3200	assert_or_panic(vec[273] == false);
	3201	assert_or_panic(vec[274] == false);
	3202	assert_or_panic(vec[275] == false);
	3203	assert_or_panic(vec[276] == false);
	3204	assert_or_panic(vec[277] == true);
	3205	assert_or_panic(vec[278] == false);
	3206	assert_or_panic(vec[279] == true);
	3207	assert_or_panic(vec[280] == true);
	3208	assert_or_panic(vec[281] == true);
	3209	assert_or_panic(vec[282] == true);
	3210	assert_or_panic(vec[283] == true);
	3211	assert_or_panic(vec[284] == false);
	3212	assert_or_panic(vec[285] == false);
	3213	assert_or_panic(vec[286] == false);
	3214	assert_or_panic(vec[287] == false);
	3215	assert_or_panic(vec[288] == false);
	3216	assert_or_panic(vec[289] == false);
	3217	assert_or_panic(vec[290] == false);
	3218	assert_or_panic(vec[291] == false);
	3219	assert_or_panic(vec[292] == false);
	3220	assert_or_panic(vec[293] == true);
	3221	assert_or_panic(vec[294] == true);
	3222	assert_or_panic(vec[295] == true);
	3223	assert_or_panic(vec[296] == true);
	3224	assert_or_panic(vec[297] == true);
	3225	assert_or_panic(vec[298] == true);
	3226	assert_or_panic(vec[299] == false);
	3227	assert_or_panic(vec[300] == true);
	3228	assert_or_panic(vec[301] == false);
	3229	assert_or_panic(vec[302] == true);
	3230	assert_or_panic(vec[303] == true);
	3231	assert_or_panic(vec[304] == true);
	3232	assert_or_panic(vec[305] == false);
	3233	assert_or_panic(vec[306] == false);
	3234	assert_or_panic(vec[307] == true);
	3235	assert_or_panic(vec[308] == true);
	3236	assert_or_panic(vec[309] == true);
	3237	assert_or_panic(vec[310] == false);
	3238	assert_or_panic(vec[311] == true);
	3239	assert_or_panic(vec[312] == true);
	3240	assert_or_panic(vec[313] == true);
	3241	assert_or_panic(vec[314] == false);
	3242	assert_or_panic(vec[315] == true);
	3243	assert_or_panic(vec[316] == true);
	3244	assert_or_panic(vec[317] == true);
	3245	assert_or_panic(vec[318] == false);
	3246	assert_or_panic(vec[319] == true);
	3247	assert_or_panic(vec[320] == true);
	3248	assert_or_panic(vec[321] == false);
	3249	assert_or_panic(vec[322] == false);
	3250	assert_or_panic(vec[323] == true);
	3251	assert_or_panic(vec[324] == false);
	3252	assert_or_panic(vec[325] == false);
	3253	assert_or_panic(vec[326] == false);
	3254	assert_or_panic(vec[327] == false);
	3255	assert_or_panic(vec[328] == true);
	3256	assert_or_panic(vec[329] == false);
	3257	assert_or_panic(vec[330] == true);
	3258	assert_or_panic(vec[331] == true);
	3259	assert_or_panic(vec[332] == true);
	3260	assert_or_panic(vec[333] == true);
	3261	assert_or_panic(vec[334] == false);
	3262	assert_or_panic(vec[335] == false);
	3263	assert_or_panic(vec[336] == true);
	3264	assert_or_panic(vec[337] == false);
	3265	assert_or_panic(vec[338] == true);
	3266	assert_or_panic(vec[339] == false);
	3267	assert_or_panic(vec[340] == false);
	3268	assert_or_panic(vec[341] == false);
	3269	assert_or_panic(vec[342] == true);
	3270	assert_or_panic(vec[343] == false);
	3271	assert_or_panic(vec[344] == true);
	3272	assert_or_panic(vec[345] == false);
	3273	assert_or_panic(vec[346] == false);
	3274	assert_or_panic(vec[347] == true);
	3275	assert_or_panic(vec[348] == true);
	3276	assert_or_panic(vec[349] == true);
	3277	assert_or_panic(vec[350] == true);
	3278	assert_or_panic(vec[351] == false);
	3279	assert_or_panic(vec[352] == false);
	3280	assert_or_panic(vec[353] == false);
	3281	assert_or_panic(vec[354] == true);
	3282	assert_or_panic(vec[355] == true);
	3283	assert_or_panic(vec[356] == false);
	3284	assert_or_panic(vec[357] == true);
	3285	assert_or_panic(vec[358] == false);
	3286	assert_or_panic(vec[359] == false);
	3287	assert_or_panic(vec[360] == true);
	3288	assert_or_panic(vec[361] == false);
	3289	assert_or_panic(vec[362] == true);
	3290	assert_or_panic(vec[363] == false);
	3291	assert_or_panic(vec[364] == true);
	3292	assert_or_panic(vec[365] == true);
	3293	assert_or_panic(vec[366] == false);
	3294	assert_or_panic(vec[367] == false);
	3295	assert_or_panic(vec[368] == true);
	3296	assert_or_panic(vec[369] == true);
	3297	assert_or_panic(vec[370] == true);
	3298	assert_or_panic(vec[371] == true);
	3299	assert_or_panic(vec[372] == false);
	3300	assert_or_panic(vec[373] == false);
	3301	assert_or_panic(vec[374] == true);
	3302	assert_or_panic(vec[375] == false);
	3303	assert_or_panic(vec[376] == true);
	3304	assert_or_panic(vec[377] == true);
	3305	assert_or_panic(vec[378] == false);
	3306	assert_or_panic(vec[379] == true);
	3307	assert_or_panic(vec[380] == true);
	3308	assert_or_panic(vec[381] == false);
	3309	assert_or_panic(vec[382] == true);
	3310	assert_or_panic(vec[383] == true);
	3311	assert_or_panic(vec[384] == true);
	3312	assert_or_panic(vec[385] == false);
	3313	assert_or_panic(vec[386] == true);
	3314	assert_or_panic(vec[387] == true);
	3315	assert_or_panic(vec[388] == true);
	3316	assert_or_panic(vec[389] == false);
	3317	assert_or_panic(vec[390] == false);
	3318	assert_or_panic(vec[391] == true);
	3319	assert_or_panic(vec[392] == false);
	3320	assert_or_panic(vec[393] == true);
	3321	assert_or_panic(vec[394] == true);
	3322	assert_or_panic(vec[395] == true);
	3323	assert_or_panic(vec[396] == false);
	3324	assert_or_panic(vec[397] == false);
	3325	assert_or_panic(vec[398] == false);
	3326	assert_or_panic(vec[399] == false);
	3327	assert_or_panic(vec[400] == false);
	3328	assert_or_panic(vec[401] == true);
	3329	assert_or_panic(vec[402] == false);
	3330	assert_or_panic(vec[403] == false);
	3331	assert_or_panic(vec[404] == false);
	3332	assert_or_panic(vec[405] == false);
	3333	assert_or_panic(vec[406] == true);
	3334	assert_or_panic(vec[407] == false);
	3335	assert_or_panic(vec[408] == false);
	3336	assert_or_panic(vec[409] == true);
	3337	assert_or_panic(vec[410] == true);
	3338	assert_or_panic(vec[411] == false);
	3339	assert_or_panic(vec[412] == false);
	3340	assert_or_panic(vec[413] == false);
	3341	assert_or_panic(vec[414] == false);
	3342	assert_or_panic(vec[415] == true);
	3343	assert_or_panic(vec[416] == true);
	3344	assert_or_panic(vec[417] == true);
	3345	assert_or_panic(vec[418] == true);
	3346	assert_or_panic(vec[419] == true);
	3347	assert_or_panic(vec[420] == false);
	3348	assert_or_panic(vec[421] == false);
	3349	assert_or_panic(vec[422] == false);
	3350	assert_or_panic(vec[423] == true);
	3351	assert_or_panic(vec[424] == false);
	3352	assert_or_panic(vec[425] == false);
	3353	assert_or_panic(vec[426] == false);
	3354	assert_or_panic(vec[427] == false);
	3355	assert_or_panic(vec[428] == true);
	3356	assert_or_panic(vec[429] == false);
	3357	assert_or_panic(vec[430] == true);
	3358	assert_or_panic(vec[431] == false);
	3359	assert_or_panic(vec[432] == true);
	3360	assert_or_panic(vec[433] == true);
	3361	assert_or_panic(vec[434] == true);
	3362	assert_or_panic(vec[435] == true);
	3363	assert_or_panic(vec[436] == false);
	3364	assert_or_panic(vec[437] == false);
	3365	assert_or_panic(vec[438] == false);
	3366	assert_or_panic(vec[439] == false);
	3367	assert_or_panic(vec[440] == false);
	3368	assert_or_panic(vec[441] == true);
	3369	assert_or_panic(vec[442] == true);
	3370	assert_or_panic(vec[443] == true);
	3371	assert_or_panic(vec[444] == true);
	3372	assert_or_panic(vec[445] == true);
	3373	assert_or_panic(vec[446] == true);
	3374	assert_or_panic(vec[447] == true);
	3375	assert_or_panic(vec[448] == true);
	3376	assert_or_panic(vec[449] == true);
	3377	assert_or_panic(vec[450] == false);
	3378	assert_or_panic(vec[451] == false);
	3379	assert_or_panic(vec[452] == true);
	3380	assert_or_panic(vec[453] == false);
	3381	assert_or_panic(vec[454] == true);
	3382	assert_or_panic(vec[455] == false);
	3383	assert_or_panic(vec[456] == false);
	3384	assert_or_panic(vec[457] == true);
	3385	assert_or_panic(vec[458] == false);
	3386	assert_or_panic(vec[459] == false);
	3387	assert_or_panic(vec[460] == true);
	3388	assert_or_panic(vec[461] == true);
	3389	assert_or_panic(vec[462] == true);
	3390	assert_or_panic(vec[463] == true);
	3391	assert_or_panic(vec[464] == true);
	3392	assert_or_panic(vec[465] == true);
	3393	assert_or_panic(vec[466] == false);
	3394	assert_or_panic(vec[467] == true);
	3395	assert_or_panic(vec[468] == false);
	3396	assert_or_panic(vec[469] == false);
	3397	assert_or_panic(vec[470] == false);
	3398	assert_or_panic(vec[471] == true);
	3399	assert_or_panic(vec[472] == true);
	3400	assert_or_panic(vec[473] == false);
	3401	assert_or_panic(vec[474] == true);
	3402	assert_or_panic(vec[475] == true);
	3403	assert_or_panic(vec[476] == false);
	3404	assert_or_panic(vec[477] == false);
	3405	assert_or_panic(vec[478] == true);
	3406	assert_or_panic(vec[479] == true);
	3407	assert_or_panic(vec[480] == false);
	3408	assert_or_panic(vec[481] == false);
	3409	assert_or_panic(vec[482] == true);
	3410	assert_or_panic(vec[483] == true);
	3411	assert_or_panic(vec[484] == false);
	3412	assert_or_panic(vec[485] == true);
	3413	assert_or_panic(vec[486] == false);
	3414	assert_or_panic(vec[487] == true);
	3415	assert_or_panic(vec[488] == true);
	3416	assert_or_panic(vec[489] == true);
	3417	assert_or_panic(vec[490] == true);
	3418	assert_or_panic(vec[491] == true);
	3419	assert_or_panic(vec[492] == true);
	3420	assert_or_panic(vec[493] == true);
	3421	assert_or_panic(vec[494] == true);
	3422	assert_or_panic(vec[495] == true);
	3423	assert_or_panic(vec[496] == false);
	3424	assert_or_panic(vec[497] == true);
	3425	assert_or_panic(vec[498] == true);
	3426	assert_or_panic(vec[499] == true);
	3427	assert_or_panic(vec[500] == false);
	3428	assert_or_panic(vec[501] == false);
	3429	assert_or_panic(vec[502] == true);
	3430	assert_or_panic(vec[503] == false);
	3431	assert_or_panic(vec[504] == false);
	3432	assert_or_panic(vec[505] == false);
	3433	assert_or_panic(vec[506] == true);
	3434	assert_or_panic(vec[507] == true);
	3435	assert_or_panic(vec[508] == false);
	3436	assert_or_panic(vec[509] == true);
	3437	assert_or_panic(vec[510] == false);
	3438	assert_or_panic(vec[511] == true);
	3439	}
	3440	#endif
	3441	void c_test_vector_512_bool(void) {
	3442	Vector_512_bool vec = zig_ret_vector_512_bool();
	3443	assert_or_panic(vec[0] == true);
	3444	assert_or_panic(vec[1] == true);
	3445	assert_or_panic(vec[2] == true);
	3446	assert_or_panic(vec[3] == true);
	3447	assert_or_panic(vec[4] == false);
	3448	assert_or_panic(vec[5] == true);
	3449	assert_or_panic(vec[6] == false);
	3450	assert_or_panic(vec[7] == true);
	3451	assert_or_panic(vec[8] == true);
	3452	assert_or_panic(vec[9] == true);
	3453	assert_or_panic(vec[10] == false);
	3454	assert_or_panic(vec[11] == true);
	3455	assert_or_panic(vec[12] == false);
	3456	assert_or_panic(vec[13] == false);
	3457	assert_or_panic(vec[14] == false);
	3458	assert_or_panic(vec[15] == true);
	3459	assert_or_panic(vec[16] == true);
	3460	assert_or_panic(vec[17] == false);
	3461	assert_or_panic(vec[18] == false);
	3462	assert_or_panic(vec[19] == false);
	3463	assert_or_panic(vec[20] == true);
	3464	assert_or_panic(vec[21] == true);
	3465	assert_or_panic(vec[22] == false);
	3466	assert_or_panic(vec[23] == false);
	3467	assert_or_panic(vec[24] == false);
	3468	assert_or_panic(vec[25] == false);
	3469	assert_or_panic(vec[26] == true);
	3470	assert_or_panic(vec[27] == false);
	3471	assert_or_panic(vec[28] == false);
	3472	assert_or_panic(vec[29] == false);
	3473	assert_or_panic(vec[30] == true);
	3474	assert_or_panic(vec[31] == true);
	3475	assert_or_panic(vec[32] == true);
	3476	assert_or_panic(vec[33] == true);
	3477	assert_or_panic(vec[34] == false);
	3478	assert_or_panic(vec[35] == false);
	3479	assert_or_panic(vec[36] == false);
	3480	assert_or_panic(vec[37] == true);
	3481	assert_or_panic(vec[38] == true);
	3482	assert_or_panic(vec[39] == true);
	3483	assert_or_panic(vec[40] == false);
	3484	assert_or_panic(vec[41] == false);
	3485	assert_or_panic(vec[42] == true);
	3486	assert_or_panic(vec[43] == false);
	3487	assert_or_panic(vec[44] == false);
	3488	assert_or_panic(vec[45] == true);
	3489	assert_or_panic(vec[46] == false);
	3490	assert_or_panic(vec[47] == false);
	3491	assert_or_panic(vec[48] == true);
	3492	assert_or_panic(vec[49] == true);
	3493	assert_or_panic(vec[50] == true);
	3494	assert_or_panic(vec[51] == true);
	3495	assert_or_panic(vec[52] == false);
	3496	assert_or_panic(vec[53] == false);
	3497	assert_or_panic(vec[54] == false);
	3498	assert_or_panic(vec[55] == true);
	3499	assert_or_panic(vec[56] == false);
	3500	assert_or_panic(vec[57] == true);
	3501	assert_or_panic(vec[58] == false);
	3502	assert_or_panic(vec[59] == true);
	3503	assert_or_panic(vec[60] == true);
	3504	assert_or_panic(vec[61] == false);
	3505	assert_or_panic(vec[62] == false);
	3506	assert_or_panic(vec[63] == true);
	3507	assert_or_panic(vec[64] == true);
	3508	assert_or_panic(vec[65] == false);
	3509	assert_or_panic(vec[66] == true);
	3510	assert_or_panic(vec[67] == false);
	3511	assert_or_panic(vec[68] == false);
	3512	assert_or_panic(vec[69] == false);
	3513	assert_or_panic(vec[70] == true);
	3514	assert_or_panic(vec[71] == true);
	3515	assert_or_panic(vec[72] == true);
	3516	assert_or_panic(vec[73] == true);
	3517	assert_or_panic(vec[74] == true);
	3518	assert_or_panic(vec[75] == false);
	3519	assert_or_panic(vec[76] == true);
	3520	assert_or_panic(vec[77] == false);
	3521	assert_or_panic(vec[78] == true);
	3522	assert_or_panic(vec[79] == true);
	3523	assert_or_panic(vec[80] == true);
	3524	assert_or_panic(vec[81] == true);
	3525	assert_or_panic(vec[82] == true);
	3526	assert_or_panic(vec[83] == false);
	3527	assert_or_panic(vec[84] == true);
	3528	assert_or_panic(vec[85] == true);
	3529	assert_or_panic(vec[86] == false);
	3530	assert_or_panic(vec[87] == true);
	3531	assert_or_panic(vec[88] == false);
	3532	assert_or_panic(vec[89] == false);
	3533	assert_or_panic(vec[90] == true);
	3534	assert_or_panic(vec[91] == false);
	3535	assert_or_panic(vec[92] == true);
	3536	assert_or_panic(vec[93] == false);
	3537	assert_or_panic(vec[94] == false);
	3538	assert_or_panic(vec[95] == false);
	3539	assert_or_panic(vec[96] == true);
	3540	assert_or_panic(vec[97] == true);
	3541	assert_or_panic(vec[98] == false);
	3542	assert_or_panic(vec[99] == true);
	3543	assert_or_panic(vec[100] == true);
	3544	assert_or_panic(vec[101] == false);
	3545	assert_or_panic(vec[102] == true);
	3546	assert_or_panic(vec[103] == false);
	3547	assert_or_panic(vec[104] == true);
	3548	assert_or_panic(vec[105] == false);
	3549	assert_or_panic(vec[106] == true);
	3550	assert_or_panic(vec[107] == false);
	3551	assert_or_panic(vec[108] == false);
	3552	assert_or_panic(vec[109] == true);
	3553	assert_or_panic(vec[110] == false);
	3554	assert_or_panic(vec[111] == false);
	3555	assert_or_panic(vec[112] == true);
	3556	assert_or_panic(vec[113] == false);
	3557	assert_or_panic(vec[114] == true);
	3558	assert_or_panic(vec[115] == false);
	3559	assert_or_panic(vec[116] == true);
	3560	assert_or_panic(vec[117] == false);
	3561	assert_or_panic(vec[118] == false);
	3562	assert_or_panic(vec[119] == true);
	3563	assert_or_panic(vec[120] == true);
	3564	assert_or_panic(vec[121] == true);
	3565	assert_or_panic(vec[122] == false);
	3566	assert_or_panic(vec[123] == true);
	3567	assert_or_panic(vec[124] == false);
	3568	assert_or_panic(vec[125] == false);
	3569	assert_or_panic(vec[126] == true);
	3570	assert_or_panic(vec[127] == true);
	3571	assert_or_panic(vec[128] == false);
	3572	assert_or_panic(vec[129] == true);
	3573	assert_or_panic(vec[130] == true);
	3574	assert_or_panic(vec[131] == false);
	3575	assert_or_panic(vec[132] == true);
	3576	assert_or_panic(vec[133] == true);
	3577	assert_or_panic(vec[134] == false);
	3578	assert_or_panic(vec[135] == true);
	3579	assert_or_panic(vec[136] == true);
	3580	assert_or_panic(vec[137] == false);
	3581	assert_or_panic(vec[138] == false);
	3582	assert_or_panic(vec[139] == false);
	3583	assert_or_panic(vec[140] == true);
	3584	assert_or_panic(vec[141] == false);
	3585	assert_or_panic(vec[142] == true);
	3586	assert_or_panic(vec[143] == false);
	3587	assert_or_panic(vec[144] == false);
	3588	assert_or_panic(vec[145] == false);
	3589	assert_or_panic(vec[146] == true);
	3590	assert_or_panic(vec[147] == false);
	3591	assert_or_panic(vec[148] == true);
	3592	assert_or_panic(vec[149] == false);
	3593	assert_or_panic(vec[150] == false);
	3594	assert_or_panic(vec[151] == true);
	3595	assert_or_panic(vec[152] == false);
	3596	assert_or_panic(vec[153] == true);
	3597	assert_or_panic(vec[154] == true);
	3598	assert_or_panic(vec[155] == false);
	3599	assert_or_panic(vec[156] == true);
	3600	assert_or_panic(vec[157] == true);
	3601	assert_or_panic(vec[158] == false);
	3602	assert_or_panic(vec[159] == true);
	3603	assert_or_panic(vec[160] == true);
	3604	assert_or_panic(vec[161] == false);
	3605	assert_or_panic(vec[162] == false);
	3606	assert_or_panic(vec[163] == false);
	3607	assert_or_panic(vec[164] == true);
	3608	assert_or_panic(vec[165] == false);
	3609	assert_or_panic(vec[166] == true);
	3610	assert_or_panic(vec[167] == true);
	3611	assert_or_panic(vec[168] == true);
	3612	assert_or_panic(vec[169] == true);
	3613	assert_or_panic(vec[170] == false);
	3614	assert_or_panic(vec[171] == true);
	3615	assert_or_panic(vec[172] == false);
	3616	assert_or_panic(vec[173] == false);
	3617	assert_or_panic(vec[174] == true);
	3618	assert_or_panic(vec[175] == true);
	3619	assert_or_panic(vec[176] == true);
	3620	assert_or_panic(vec[177] == false);
	3621	assert_or_panic(vec[178] == false);
	3622	assert_or_panic(vec[179] == false);
	3623	assert_or_panic(vec[180] == true);
	3624	assert_or_panic(vec[181] == false);
	3625	assert_or_panic(vec[182] == false);
	3626	assert_or_panic(vec[183] == true);
	3627	assert_or_panic(vec[184] == true);
	3628	assert_or_panic(vec[185] == false);
	3629	assert_or_panic(vec[186] == true);
	3630	assert_or_panic(vec[187] == false);
	3631	assert_or_panic(vec[188] == true);
	3632	assert_or_panic(vec[189] == true);
	3633	assert_or_panic(vec[190] == true);
	3634	assert_or_panic(vec[191] == true);
	3635	assert_or_panic(vec[192] == true);
	3636	assert_or_panic(vec[193] == true);
	3637	assert_or_panic(vec[194] == true);
	3638	assert_or_panic(vec[195] == false);
	3639	assert_or_panic(vec[196] == false);
	3640	assert_or_panic(vec[197] == false);
	3641	assert_or_panic(vec[198] == false);
	3642	assert_or_panic(vec[199] == false);
	3643	assert_or_panic(vec[200] == true);
	3644	assert_or_panic(vec[201] == false);
	3645	assert_or_panic(vec[202] == true);
	3646	assert_or_panic(vec[203] == false);
	3647	assert_or_panic(vec[204] == true);
	3648	assert_or_panic(vec[205] == true);
	3649	assert_or_panic(vec[206] == false);
	3650	assert_or_panic(vec[207] == false);
	3651	assert_or_panic(vec[208] == false);
	3652	assert_or_panic(vec[209] == true);
	3653	assert_or_panic(vec[210] == true);
	3654	assert_or_panic(vec[211] == true);
	3655	assert_or_panic(vec[212] == false);
	3656	assert_or_panic(vec[213] == false);
	3657	assert_or_panic(vec[214] == true);
	3658	assert_or_panic(vec[215] == true);
	3659	assert_or_panic(vec[216] == true);
	3660	assert_or_panic(vec[217] == false);
	3661	assert_or_panic(vec[218] == false);
	3662	assert_or_panic(vec[219] == true);
	3663	assert_or_panic(vec[220] == false);
	3664	assert_or_panic(vec[221] == true);
	3665	assert_or_panic(vec[222] == true);
	3666	assert_or_panic(vec[223] == false);
	3667	assert_or_panic(vec[224] == true);
	3668	assert_or_panic(vec[225] == false);
	3669	assert_or_panic(vec[226] == false);
	3670	assert_or_panic(vec[227] == true);
	3671	assert_or_panic(vec[228] == false);
	3672	assert_or_panic(vec[229] == false);
	3673	assert_or_panic(vec[230] == true);
	3674	assert_or_panic(vec[231] == true);
	3675	assert_or_panic(vec[232] == false);
	3676	assert_or_panic(vec[233] == true);
	3677	assert_or_panic(vec[234] == true);
	3678	assert_or_panic(vec[235] == true);
	3679	assert_or_panic(vec[236] == true);
	3680	assert_or_panic(vec[237] == true);
	3681	assert_or_panic(vec[238] == false);
	3682	assert_or_panic(vec[239] == true);
	3683	assert_or_panic(vec[240] == false);
	3684	assert_or_panic(vec[241] == false);
	3685	assert_or_panic(vec[242] == true);
	3686	assert_or_panic(vec[243] == false);
	3687	assert_or_panic(vec[244] == true);
	3688	assert_or_panic(vec[245] == false);
	3689	assert_or_panic(vec[246] == true);
	3690	assert_or_panic(vec[247] == false);
	3691	assert_or_panic(vec[248] == true);
	3692	assert_or_panic(vec[249] == true);
	3693	assert_or_panic(vec[250] == true);
	3694	assert_or_panic(vec[251] == true);
	3695	assert_or_panic(vec[252] == true);
	3696	assert_or_panic(vec[253] == false);
	3697	assert_or_panic(vec[254] == false);
	3698	assert_or_panic(vec[255] == false);
	3699	assert_or_panic(vec[256] == false);
	3700	assert_or_panic(vec[257] == false);
	3701	assert_or_panic(vec[258] == false);
	3702	assert_or_panic(vec[259] == true);
	3703	assert_or_panic(vec[260] == true);
	3704	assert_or_panic(vec[261] == true);
	3705	assert_or_panic(vec[262] == true);
	3706	assert_or_panic(vec[263] == false);
	3707	assert_or_panic(vec[264] == false);
	3708	assert_or_panic(vec[265] == false);
	3709	assert_or_panic(vec[266] == true);
	3710	assert_or_panic(vec[267] == false);
	3711	assert_or_panic(vec[268] == true);
	3712	assert_or_panic(vec[269] == false);
	3713	assert_or_panic(vec[270] == true);
	3714	assert_or_panic(vec[271] == true);
	3715	assert_or_panic(vec[272] == true);
	3716	assert_or_panic(vec[273] == true);
	3717	assert_or_panic(vec[274] == true);
	3718	assert_or_panic(vec[275] == true);
	3719	assert_or_panic(vec[276] == false);
	3720	assert_or_panic(vec[277] == false);
	3721	assert_or_panic(vec[278] == true);
	3722	assert_or_panic(vec[279] == true);
	3723	assert_or_panic(vec[280] == false);
	3724	assert_or_panic(vec[281] == false);
	3725	assert_or_panic(vec[282] == false);
	3726	assert_or_panic(vec[283] == false);
	3727	assert_or_panic(vec[284] == true);
	3728	assert_or_panic(vec[285] == true);
	3729	assert_or_panic(vec[286] == true);
	3730	assert_or_panic(vec[287] == false);
	3731	assert_or_panic(vec[288] == false);
	3732	assert_or_panic(vec[289] == false);
	3733	assert_or_panic(vec[290] == true);
	3734	assert_or_panic(vec[291] == false);
	3735	assert_or_panic(vec[292] == true);
	3736	assert_or_panic(vec[293] == true);
	3737	assert_or_panic(vec[294] == false);
	3738	assert_or_panic(vec[295] == true);
	3739	assert_or_panic(vec[296] == true);
	3740	assert_or_panic(vec[297] == true);
	3741	assert_or_panic(vec[298] == false);
	3742	assert_or_panic(vec[299] == true);
	3743	assert_or_panic(vec[300] == true);
	3744	assert_or_panic(vec[301] == false);
	3745	assert_or_panic(vec[302] == false);
	3746	assert_or_panic(vec[303] == true);
	3747	assert_or_panic(vec[304] == false);
	3748	assert_or_panic(vec[305] == false);
	3749	assert_or_panic(vec[306] == true);
	3750	assert_or_panic(vec[307] == true);
	3751	assert_or_panic(vec[308] == true);
	3752	assert_or_panic(vec[309] == true);
	3753	assert_or_panic(vec[310] == false);
	3754	assert_or_panic(vec[311] == false);
	3755	assert_or_panic(vec[312] == false);
	3756	assert_or_panic(vec[313] == false);
	3757	assert_or_panic(vec[314] == false);
	3758	assert_or_panic(vec[315] == true);
	3759	assert_or_panic(vec[316] == false);
	3760	assert_or_panic(vec[317] == false);
	3761	assert_or_panic(vec[318] == true);
	3762	assert_or_panic(vec[319] == false);
	3763	assert_or_panic(vec[320] == false);
	3764	assert_or_panic(vec[321] == true);
	3765	assert_or_panic(vec[322] == true);
	3766	assert_or_panic(vec[323] == true);
	3767	assert_or_panic(vec[324] == true);
	3768	assert_or_panic(vec[325] == false);
	3769	assert_or_panic(vec[326] == false);
	3770	assert_or_panic(vec[327] == false);
	3771	assert_or_panic(vec[328] == true);
	3772	assert_or_panic(vec[329] == true);
	3773	assert_or_panic(vec[330] == false);
	3774	assert_or_panic(vec[331] == true);
	3775	assert_or_panic(vec[332] == true);
	3776	assert_or_panic(vec[333] == false);
	3777	assert_or_panic(vec[334] == false);
	3778	assert_or_panic(vec[335] == true);
	3779	assert_or_panic(vec[336] == true);
	3780	assert_or_panic(vec[337] == false);
	3781	assert_or_panic(vec[338] == true);
	3782	assert_or_panic(vec[339] == true);
	3783	assert_or_panic(vec[340] == true);
	3784	assert_or_panic(vec[341] == false);
	3785	assert_or_panic(vec[342] == false);
	3786	assert_or_panic(vec[343] == false);
	3787	assert_or_panic(vec[344] == true);
	3788	assert_or_panic(vec[345] == true);
	3789	assert_or_panic(vec[346] == false);
	3790	assert_or_panic(vec[347] == true);
	3791	assert_or_panic(vec[348] == false);
	3792	assert_or_panic(vec[349] == true);
	3793	assert_or_panic(vec[350] == false);
	3794	assert_or_panic(vec[351] == false);
	3795	assert_or_panic(vec[352] == true);
	3796	assert_or_panic(vec[353] == false);
	3797	assert_or_panic(vec[354] == true);
	3798	assert_or_panic(vec[355] == false);
	3799	assert_or_panic(vec[356] == false);
	3800	assert_or_panic(vec[357] == false);
	3801	assert_or_panic(vec[358] == false);
	3802	assert_or_panic(vec[359] == false);
	3803	assert_or_panic(vec[360] == true);
	3804	assert_or_panic(vec[361] == true);
	3805	assert_or_panic(vec[362] == false);
	3806	assert_or_panic(vec[363] == false);
	3807	assert_or_panic(vec[364] == false);
	3808	assert_or_panic(vec[365] == false);
	3809	assert_or_panic(vec[366] == true);
	3810	assert_or_panic(vec[367] == false);
	3811	assert_or_panic(vec[368] == true);
	3812	assert_or_panic(vec[369] == false);
	3813	assert_or_panic(vec[370] == true);
	3814	assert_or_panic(vec[371] == true);
	3815	assert_or_panic(vec[372] == false);
	3816	assert_or_panic(vec[373] == true);
	3817	assert_or_panic(vec[374] == true);
	3818	assert_or_panic(vec[375] == true);
	3819	assert_or_panic(vec[376] == true);
	3820	assert_or_panic(vec[377] == true);
	3821	assert_or_panic(vec[378] == false);
	3822	assert_or_panic(vec[379] == true);
	3823	assert_or_panic(vec[380] == false);
	3824	assert_or_panic(vec[381] == true);
	3825	assert_or_panic(vec[382] == true);
	3826	assert_or_panic(vec[383] == true);
	3827	assert_or_panic(vec[384] == true);
	3828	assert_or_panic(vec[385] == true);
	3829	assert_or_panic(vec[386] == false);
	3830	assert_or_panic(vec[387] == true);
	3831	assert_or_panic(vec[388] == true);
	3832	assert_or_panic(vec[389] == false);
	3833	assert_or_panic(vec[390] == true);
	3834	assert_or_panic(vec[391] == false);
	3835	assert_or_panic(vec[392] == true);
	3836	assert_or_panic(vec[393] == false);
	3837	assert_or_panic(vec[394] == true);
	3838	assert_or_panic(vec[395] == false);
	3839	assert_or_panic(vec[396] == true);
	3840	assert_or_panic(vec[397] == false);
	3841	assert_or_panic(vec[398] == false);
	3842	assert_or_panic(vec[399] == true);
	3843	assert_or_panic(vec[400] == true);
	3844	assert_or_panic(vec[401] == true);
	3845	assert_or_panic(vec[402] == true);
	3846	assert_or_panic(vec[403] == false);
	3847	assert_or_panic(vec[404] == false);
	3848	assert_or_panic(vec[405] == true);
	3849	assert_or_panic(vec[406] == false);
	3850	assert_or_panic(vec[407] == false);
	3851	assert_or_panic(vec[408] == false);
	3852	assert_or_panic(vec[409] == true);
	3853	assert_or_panic(vec[410] == false);
	3854	assert_or_panic(vec[411] == true);
	3855	assert_or_panic(vec[412] == true);
	3856	assert_or_panic(vec[413] == false);
	3857	assert_or_panic(vec[414] == true);
	3858	assert_or_panic(vec[415] == true);
	3859	assert_or_panic(vec[416] == false);
	3860	assert_or_panic(vec[417] == true);
	3861	assert_or_panic(vec[418] == true);
	3862	assert_or_panic(vec[419] == false);
	3863	assert_or_panic(vec[420] == false);
	3864	assert_or_panic(vec[421] == true);
	3865	assert_or_panic(vec[422] == false);
	3866	assert_or_panic(vec[423] == false);
	3867	assert_or_panic(vec[424] == true);
	3868	assert_or_panic(vec[425] == false);
	3869	assert_or_panic(vec[426] == true);
	3870	assert_or_panic(vec[427] == false);
	3871	assert_or_panic(vec[428] == false);
	3872	assert_or_panic(vec[429] == true);
	3873	assert_or_panic(vec[430] == false);
	3874	assert_or_panic(vec[431] == true);
	3875	assert_or_panic(vec[432] == true);
	3876	assert_or_panic(vec[433] == false);
	3877	assert_or_panic(vec[434] == true);
	3878	assert_or_panic(vec[435] == false);
	3879	assert_or_panic(vec[436] == true);
	3880	assert_or_panic(vec[437] == false);
	3881	assert_or_panic(vec[438] == true);
	3882	assert_or_panic(vec[439] == false);
	3883	assert_or_panic(vec[440] == false);
	3884	assert_or_panic(vec[441] == true);
	3885	assert_or_panic(vec[442] == true);
	3886	assert_or_panic(vec[443] == false);
	3887	assert_or_panic(vec[444] == true);
	3888	assert_or_panic(vec[445] == true);
	3889	assert_or_panic(vec[446] == false);
	3890	assert_or_panic(vec[447] == true);
	3891	assert_or_panic(vec[448] == true);
	3892	assert_or_panic(vec[449] == false);
	3893	assert_or_panic(vec[450] == false);
	3894	assert_or_panic(vec[451] == false);
	3895	assert_or_panic(vec[452] == false);
	3896	assert_or_panic(vec[453] == false);
	3897	assert_or_panic(vec[454] == true);
	3898	assert_or_panic(vec[455] == false);
	3899	assert_or_panic(vec[456] == false);
	3900	assert_or_panic(vec[457] == true);
	3901	assert_or_panic(vec[458] == false);
	3902	assert_or_panic(vec[459] == true);
	3903	assert_or_panic(vec[460] == false);
	3904	assert_or_panic(vec[461] == false);
	3905	assert_or_panic(vec[462] == false);
	3906	assert_or_panic(vec[463] == true);
	3907	assert_or_panic(vec[464] == false);
	3908	assert_or_panic(vec[465] == true);
	3909	assert_or_panic(vec[466] == false);
	3910	assert_or_panic(vec[467] == false);
	3911	assert_or_panic(vec[468] == false);
	3912	assert_or_panic(vec[469] == false);
	3913	assert_or_panic(vec[470] == true);
	3914	assert_or_panic(vec[471] == true);
	3915	assert_or_panic(vec[472] == false);
	3916	assert_or_panic(vec[473] == true);
	3917	assert_or_panic(vec[474] == true);
	3918	assert_or_panic(vec[475] == false);
	3919	assert_or_panic(vec[476] == false);
	3920	assert_or_panic(vec[477] == true);
	3921	assert_or_panic(vec[478] == true);
	3922	assert_or_panic(vec[479] == true);
	3923	assert_or_panic(vec[480] == false);
	3924	assert_or_panic(vec[481] == false);
	3925	assert_or_panic(vec[482] == true);
	3926	assert_or_panic(vec[483] == false);
	3927	assert_or_panic(vec[484] == false);
	3928	assert_or_panic(vec[485] == false);
	3929	assert_or_panic(vec[486] == true);
	3930	assert_or_panic(vec[487] == true);
	3931	assert_or_panic(vec[488] == false);
	3932	assert_or_panic(vec[489] == false);
	3933	assert_or_panic(vec[490] == false);
	3934	assert_or_panic(vec[491] == false);
	3935	assert_or_panic(vec[492] == false);
	3936	assert_or_panic(vec[493] == true);
	3937	assert_or_panic(vec[494] == true);
	3938	assert_or_panic(vec[495] == true);
	3939	assert_or_panic(vec[496] == true);
	3940	assert_or_panic(vec[497] == false);
	3941	assert_or_panic(vec[498] == false);
	3942	assert_or_panic(vec[499] == false);
	3943	assert_or_panic(vec[500] == true);
	3944	assert_or_panic(vec[501] == false);
	3945	assert_or_panic(vec[502] == true);
	3946	assert_or_panic(vec[503] == true);
	3947	assert_or_panic(vec[504] == true);
	3948	assert_or_panic(vec[505] == true);
	3949	assert_or_panic(vec[506] == false);
	3950	assert_or_panic(vec[507] == false);
	3951	assert_or_panic(vec[508] == true);
	3952	assert_or_panic(vec[509] == true);
	3953	assert_or_panic(vec[510] == false);
	3954	assert_or_panic(vec[511] == false);
	3955	zig_vector_512_bool((Vector_512_bool){
2360	3956	false,
2361	3957	true,
2362		false,
	3958	true,
2363	3959	false,
2364	3960	true,
2365	3961	false,
2366	3962	true,
	3963	false,
	3964	false,
	3965	false,
	3966	false,
	3967	false,
2367	3968	true,
	3969	false,
2368	3970	true,
2369	3971	false,
2370	3972	false,
	3973	false,
	3974	true,
	3975	true,
	3976	true,
2371	3977	true,
2372	3978	false,
2373	3979	false,
2374	3980	false,
2375	3981	true,
2376	3982	true,
	3983	false,
	3984	true,
2377	3985	true,
2378	3986	false,
	3987	false,
2379	3988	true,
	3989	true,
	3990	false,
	3991	false,
2380	3992	false,
2381	3993	false,
2382	3994	false,
...	...	@@ -2384,29 +3996,58 @@ Vector512Bool c_ret_vector_512_bool(void) {
2384	3996	false,
2385	3997	true,
2386	3998	true,
	3999	true,
2387	4000	false,
2388		false,
	4001	true,
	4002	true,
	4003	true,
	4004	true,
2389	4005	true,
2390	4006	false,
	4007	true,
	4008	true,
	4009	true,
2391	4010	false,
	4011	true,
2392	4012	false,
2393	4013	false,
	4014	true,
2394	4015	false,
2395	4016	true,
2396	4017	true,
2397	4018	false,
2398	4019	false,
2399	4020	false,
	4021	true,
	4022	true,
	4023	true,
	4024	true,
2400	4025	false,
2401	4026	false,
	4027	true,
	4028	true,
2402	4029	false,
2403	4030	true,
2404	4031	true,
2405	4032	false,
	4033	false,
	4034	true,
	4035	false,
	4036	false,
	4037	false,
	4038	true,
2406	4039	true,
2407	4040	true,
	4041	false,
	4042	false,
	4043	true,
	4044	false,
2408	4045	true,
	4046	false,
	4047	false,
2409	4048	true,
	4049	false,
	4050	false,
2410	4051	true,
2411	4052	true,
2412	4053	false,
...	...	@@ -2415,6 +4056,12 @@ Vector512Bool c_ret_vector_512_bool(void) {
2415	4056	false,
2416	4057	true,
2417	4058	false,
	4059	false,
	4060	false,
	4061	false,
	4062	false,
	4063	false,
	4064	true,
2418	4065	true,
2419	4066	true,
2420	4067	true,
...	...	@@ -2422,6 +4069,7 @@ Vector512Bool c_ret_vector_512_bool(void) {
2422	4069	false,
2423	4070	false,
2424	4071	false,
	4072	false,
2425	4073	true,
2426	4074	true,
2427	4075	false,
...	...	@@ -2429,72 +4077,145 @@ Vector512Bool c_ret_vector_512_bool(void) {
2429	4077	true,
2430	4078	false,
2431	4079	false,
	4080	true,
	4081	false,
	4082	false,
2432	4083	false,
	4084	false,
	4085	true,
2433	4086	true,
2434	4087	true,
2435	4088	true,
	4089	false,
	4090	false,
	4091	false,
	4092	false,
2436	4093	true,
2437	4094	false,
	4095	false,
	4096	false,
	4097	false,
	4098	true,
2438	4099	true,
2439	4100	false,
2440	4101	true,
	4102	false,
2441	4103	true,
	4104	false,
	4105	false,
2442	4106	true,
2443	4107	true,
2444	4108	false,
2445	4109	true,
	4110	true,
	4111	false,
	4112	false,
2446	4113	false,
2447	4114	true,
2448	4115	false,
	4116	false,
	4117	false,
	4118	false,
	4119	true,
2449	4120	true,
2450	4121	false,
2451	4122	false,
	4123	true,
2452	4124	false,
2453	4125	true,
2454	4126	true,
2455	4127	false,
	4128	false,
	4129	false,
	4130	false,
	4131	false,
	4132	false,
2456	4133	true,
2457	4134	false,
2458	4135	false,
2459	4136	false,
	4137	false,
	4138	false,
	4139	false,
2460	4140	true,
	4141	false,
	4142	false,
	4143	false,
	4144	false,
2461	4145	true,
	4146	false,
	4147	false,
	4148	false,
	4149	false,
	4150	false,
	4151	false,
2462	4152	true,
2463	4153	true,
2464	4154	true,
2465	4155	false,
2466	4156	true,
2467	4157	true,
	4158	false,
	4159	false,
	4160	false,
	4161	false,
	4162	false,
2468	4163	true,
2469	4164	true,
2470	4165	false,
2471		true,
2472	4166	false,
2473	4167	false,
2474	4168	true,
2475	4169	false,
	4170	false,
	4171	true,
	4172	true,
2476	4173	true,
2477	4174	false,
2478	4175	false,
2479	4176	true,
	4177	false,
	4178	true,
	4179	true,
	4180	true,
	4181	true,
	4182	false,
2480	4183	true,
2481	4184	false,
	4185	false,
	4186	false,
2482	4187	true,
2483	4188	false,
2484	4189	false,
	4190	false,
	4191	false,
	4192	false,
	4193	false,
	4194	false,
2485	4195	true,
2486	4196	false,
2487	4197	false,
	4198	false,
2488	4199	true,
2489	4200	true,
2490	4201	true,
	4202	true,
	4203	false,
	4204	true,
	4205	true,
	4206	false,
2491	4207	false,
2492	4208	false,
2493	4209	true,
	4210	false,
	4211	false,
2494	4212	true,
2495	4213	true,
2496	4214	false,
	4215	true,
2497	4216	false,
	4217	true,
	4218	true,
2498	4219	false,
2499	4220	false,
2500	4221	false,
...	...	@@ -2502,19 +4223,26 @@ Vector512Bool c_ret_vector_512_bool(void) {
2502	4223	true,
2503	4224	false,
2504	4225	true,
	4226	true,
	4227	false,
2505	4228	false,
2506	4229	true,
2507	4230	true,
	4231	true,
	4232	false,
	4233	true,
2508	4234	false,
2509	4235	false,
	4236	true,
	4237	true,
2510	4238	false,
	4239	true,
2511	4240	false,
2512	4241	true,
2513	4242	true,
2514	4243	true,
2515	4244	true,
2516	4245	true,
2517		false,
2518	4246	true,
2519	4247	true,
2520	4248	true,
...	...	@@ -2522,24 +4250,29 @@ Vector512Bool c_ret_vector_512_bool(void) {
2522	4250	true,
2523	4251	false,
2524	4252	true,
	4253	false,
	4254	true,
	4255	false,
2525	4256	true,
2526	4257	true,
2527	4258	false,
2528	4259	true,
2529	4260	false,
2530	4261	true,
	4262	false,
2531	4263	true,
2532	4264	true,
2533	4265	false,
2534		false,
2535	4266	true,
2536	4267	true,
2537	4268	true,
2538	4269	false,
2539	4270	false,
	4271	false,
	4272	false,
	4273	true,
2540	4274	true,
2541	4275	true,
2542		false,
2543	4276	true,
2544	4277	true,
2545	4278	true,
...	...	@@ -2549,65 +4282,61 @@ Vector512Bool c_ret_vector_512_bool(void) {
2549	4282	false,
2550	4283	true,
2551	4284	false,
	4285	false,
2552	4286	true,
2553	4287	false,
2554	4288	false,
2555	4289	false,
2556	4290	false,
2557		true,
2558		true,
2559		true,
2560		true,
2561	4291	false,
2562		true,
2563	4292	false,
2564		true,
2565		true,
2566	4293	false,
2567		true,
2568	4294	false,
2569	4295	false,
2570		true,
2571	4296	false,
2572	4297	false,
	4298	true,
	4299	true,
2573	4300	false,
2574	4301	false,
2575	4302	false,
2576	4303	false,
2577	4304	false,
2578	4305	true,
2579		false,
	4306	true,
2580	4307	true,
2581	4308	true,
2582	4309	false,
2583	4310	false,
2584		true,
2585	4311	false,
2586	4312	false,
2587	4313	true,
	4314	true,
2588	4315	false,
2589	4316	false,
	4317	false,
	4318	true,
2590	4319	true,
2591	4320	false,
2592	4321	false,
2593	4322	false,
2594	4323	false,
	4324	false,
2595	4325	true,
2596	4326	true,
	4327	false,
2597	4328	true,
2598	4329	true,
2599		true,
	4330	false,
2600	4331	true,
2601	4332	true,
2602	4333	false,
2603	4334	true,
2604	4335	true,
2605	4336	false,
2606		false,
2607		false,
2608	4337	true,
2609		false,
2610	4338	true,
	4339	false,
2611	4340	true,
2612	4341	false,
2613	4342	true,
...	...	@@ -2619,12 +4348,16 @@ Vector512Bool c_ret_vector_512_bool(void) {
2619	4348	false,
2620	4349	true,
2621	4350	true,
2622		false,
	4351	true,
2623	4352	true,
2624	4353	false,
2625	4354	true,
	4355	true,
	4356	true,
2626	4357	false,
2627	4358	false,
	4359	true,
	4360	false,
2628	4361	false,
2629	4362	false,
2630	4363	true,
...	...	@@ -2636,42 +4369,52 @@ Vector512Bool c_ret_vector_512_bool(void) {
2636	4369	false,
2637	4370	false,
2638	4371	true,
2639		true,
2640		false,
2641		true,
2642	4372	false,
2643	4373	false,
2644	4374	true,
2645	4375	true,
2646	4376	true,
2647	4377	true,
	4378	false,
2648	4379	true,
2649	4380	true,
2650	4381	false,
2651	4382	false,
2652	4383	false,
2653	4384	true,
	4385	false,
2654	4386	true,
2655	4387	true,
2656	4388	false,
2657	4389	false,
2658	4390	false,
2659	4391	false,
	4392	true,
2660	4393	false,
	4394	true,
2661	4395	false,
2662	4396	false,
2663	4397	false,
2664	4398	false,
	4399	true,
2665	4400	false,
2666	4401	false,
2667	4402	true,
	4403	true,
	4404	true,
2668	4405	false,
	4406	true,
	4407	true,
2669	4408	false,
	4409	true,
2670	4410	false,
2671	4411	true,
2672	4412	false,
2673	4413	false,
2674	4414	false,
	4415	true,
	4416	false,
	4417	false,
2675	4418	false,
2676	4419	true,
2677	4420	true,
...	...	@@ -2680,99 +4423,10881 @@ Vector512Bool c_ret_vector_512_bool(void) {
2680	4423	true,
2681	4424	false,
2682	4425	false,
	4426	false,
	4427	false,
	4428	false,
	4429	false,
2683	4430	true,
2684	4431	true,
2685	4432	true,
2686		false,
2687		true,
2688	4433	true,
2689	4434	true,
2690	4435	false,
2691	4436	true,
2692		false,
2693	4437	true,
2694	4438	false,
2695	4439	true,
2696	4440	false,
2697	4441	true,
2698		true,
2699		true,
2700		true,
2701	4442	false,
2702	4443	true,
2703		true,
	4444	false,
	4445	false,
2704	4446	false,
2705	4447	true,
2706	4448	false,
2707	4449	false,
2708	4450	false,
	4451	true,
	4452	true,
2709	4453	false,
2710	4454	false,
	4455	true,
2711	4456	false,
	4457	true,
2712	4458	false,
2713	4459	false,
2714	4460	false,
2715	4461	true,
2716	4462	true,
2717		false,
2718	4463	true,
	4464	true,
	4465	false,
2719	4466	false,
	4467	true,
	4468	});
	4469	}
	4470
	4471	#endif
	4472
	4473	typedef uint8_t Vector_1_u8 __attribute__((vector_size(1 * sizeof(uint8_t))));
	4474
	4475	Vector_1_u8 zig_ret_vector_1_u8(void);
	4476	void zig_vector_1_u8(Vector_1_u8, size_t);
	4477
	4478	Vector_1_u8 c_ret_vector_1_u8(void) {
	4479	return (Vector_1_u8){ 3 };
	4480	}
	4481	void c_vector_1_u8(Vector_1_u8 v, size_t i) {
	4482	assert_or_panic(v[0] == 4);
	4483	assert_or_panic(i == 1);
	4484	}
	4485	void c_test_vector_1_u8(void) {
	4486	Vector_1_u8 v = zig_ret_vector_1_u8();
	4487	assert_or_panic(v[0] == 1);
	4488	zig_vector_1_u8((Vector_1_u8){ 2 }, 1);
	4489	}
	4490
	4491	typedef uint8_t Vector_2_u8 __attribute__((vector_size(2 * sizeof(uint8_t))));
	4492
	4493	Vector_2_u8 zig_ret_vector_2_u8(void);
	4494	void zig_vector_2_u8(Vector_2_u8, size_t);
	4495
	4496	Vector_2_u8 c_ret_vector_2_u8(void) {
	4497	return (Vector_2_u8){ 9, 10 };
	4498	}
	4499	void c_vector_2_u8(Vector_2_u8 v, size_t i) {
	4500	assert_or_panic(v[0] == 11);
	4501	assert_or_panic(v[1] == 12);
	4502	assert_or_panic(i == 2);
	4503	}
	4504	void c_test_vector_2_u8(void) {
	4505	Vector_2_u8 v = zig_ret_vector_2_u8();
	4506	assert_or_panic(v[0] == 5);
	4507	assert_or_panic(v[1] == 6);
	4508	zig_vector_2_u8((Vector_2_u8){ 7, 8 }, 2);
	4509	}
	4510
	4511	typedef uint8_t Vector_3_u8 __attribute__((vector_size(3 * sizeof(uint8_t))));
	4512
	4513	Vector_3_u8 zig_ret_vector_3_u8(void);
	4514	void zig_vector_3_u8(Vector_3_u8, size_t);
	4515
	4516	Vector_3_u8 c_ret_vector_3_u8(void) {
	4517	return (Vector_3_u8){ 19, 20, 21 };
	4518	}
	4519	void c_vector_3_u8(Vector_3_u8 v, size_t i) {
	4520	assert_or_panic(v[0] == 22);
	4521	assert_or_panic(v[1] == 23);
	4522	assert_or_panic(v[2] == 24);
	4523	assert_or_panic(i == 3);
	4524	}
	4525	void c_test_vector_3_u8(void) {
	4526	Vector_3_u8 v = zig_ret_vector_3_u8();
	4527	assert_or_panic(v[0] == 13);
	4528	assert_or_panic(v[1] == 14);
	4529	assert_or_panic(v[2] == 15);
	4530	zig_vector_3_u8((Vector_3_u8){ 16, 17, 18 }, 3);
	4531	}
	4532
	4533	typedef uint8_t Vector_4_u8 __attribute__((vector_size(4 * sizeof(uint8_t))));
	4534
	4535	Vector_4_u8 zig_ret_vector_4_u8(void);
	4536	void zig_vector_4_u8(Vector_4_u8, size_t);
	4537	void zig_vector_4_u8_vector_4_u8(Vector_4_u8, Vector_4_u8, size_t);
	4538
	4539	Vector_4_u8 c_ret_vector_4_u8(void) {
	4540	return (Vector_4_u8){ 41, 42, 43, 44 };
	4541	}
	4542	void c_vector_4_u8(Vector_4_u8 v, size_t i) {
	4543	assert_or_panic(v[0] == 45);
	4544	assert_or_panic(v[1] == 46);
	4545	assert_or_panic(v[2] == 47);
	4546	assert_or_panic(v[3] == 48);
	4547	assert_or_panic(i == 4);
	4548	}
	4549	void c_vector_4_u8_vector_4_u8(Vector_4_u8 v0, Vector_4_u8 v1, size_t i) {
	4550	assert_or_panic(v0[0] == 49);
	4551	assert_or_panic(v0[1] == 50);
	4552	assert_or_panic(v0[2] == 51);
	4553	assert_or_panic(v0[3] == 52);
	4554	assert_or_panic(v1[0] == 53);
	4555	assert_or_panic(v1[1] == 54);
	4556	assert_or_panic(v1[2] == 55);
	4557	assert_or_panic(v1[3] == 56);
	4558	assert_or_panic(i == 8);
	4559	}
	4560	void c_test_vector_4_u8(void) {
	4561	Vector_4_u8 v = zig_ret_vector_4_u8();
	4562	assert_or_panic(v[0] == 25);
	4563	assert_or_panic(v[1] == 26);
	4564	assert_or_panic(v[2] == 27);
	4565	assert_or_panic(v[3] == 28);
	4566	zig_vector_4_u8((Vector_4_u8){ 29, 30, 31, 32 }, 4);
	4567	zig_vector_4_u8_vector_4_u8((Vector_4_u8){ 33, 34, 35, 36 }, (Vector_4_u8){ 37, 38, 39, 40 }, 8);
	4568	}
	4569
	4570	typedef uint8_t Vector_6_u8 __attribute__((vector_size(6 * sizeof(uint8_t))));
	4571
	4572	Vector_6_u8 zig_ret_vector_6_u8(void);
	4573	void zig_vector_6_u8(Vector_6_u8, size_t);
	4574
	4575	Vector_6_u8 c_ret_vector_6_u8(void) {
	4576	return (Vector_6_u8){ 53, 54, 55, 56, 57, 58 };
	4577	}
	4578	void c_vector_6_u8(Vector_6_u8 v, size_t i) {
	4579	assert_or_panic(v[0] == 59);
	4580	assert_or_panic(v[1] == 60);
	4581	assert_or_panic(v[2] == 61);
	4582	assert_or_panic(v[3] == 62);
	4583	assert_or_panic(v[4] == 63);
	4584	assert_or_panic(v[5] == 64);
	4585	assert_or_panic(i == 6);
	4586	}
	4587	void c_test_vector_6_u8(void) {
	4588	Vector_6_u8 v = zig_ret_vector_6_u8();
	4589	assert_or_panic(v[0] == 41);
	4590	assert_or_panic(v[1] == 42);
	4591	assert_or_panic(v[2] == 43);
	4592	assert_or_panic(v[3] == 44);
	4593	assert_or_panic(v[4] == 45);
	4594	assert_or_panic(v[5] == 46);
	4595	zig_vector_6_u8((Vector_6_u8){ 47, 48, 49, 50, 51, 52 }, 6);
	4596	}
	4597
	4598	typedef uint8_t Vector_8_u8 __attribute__((vector_size(8 * sizeof(uint8_t))));
	4599
	4600	Vector_8_u8 zig_ret_vector_8_u8(void);
	4601	void zig_vector_8_u8(Vector_8_u8, size_t);
	4602
	4603	Vector_8_u8 c_ret_vector_8_u8(void) {
	4604	return (Vector_8_u8){ 81, 82, 83, 84, 85, 86, 87, 88 };
	4605	}
	4606	void c_vector_8_u8(Vector_8_u8 v, size_t i) {
	4607	assert_or_panic(v[0] == 89);
	4608	assert_or_panic(v[1] == 90);
	4609	assert_or_panic(v[2] == 91);
	4610	assert_or_panic(v[3] == 92);
	4611	assert_or_panic(v[4] == 93);
	4612	assert_or_panic(v[5] == 94);
	4613	assert_or_panic(v[6] == 95);
	4614	assert_or_panic(v[7] == 96);
	4615	assert_or_panic(i == 8);
	4616	}
	4617	void c_test_vector_8_u8(void) {
	4618	Vector_8_u8 v = zig_ret_vector_8_u8();
	4619	assert_or_panic(v[0] == 65);
	4620	assert_or_panic(v[1] == 66);
	4621	assert_or_panic(v[2] == 67);
	4622	assert_or_panic(v[3] == 68);
	4623	assert_or_panic(v[4] == 69);
	4624	assert_or_panic(v[5] == 70);
	4625	assert_or_panic(v[6] == 71);
	4626	assert_or_panic(v[7] == 72);
	4627	zig_vector_8_u8((Vector_8_u8){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8);
	4628	}
	4629
	4630	typedef uint8_t Vector_12_u8 __attribute__((vector_size(12 * sizeof(uint8_t))));
	4631
	4632	Vector_12_u8 zig_ret_vector_12_u8(void);
	4633	void zig_vector_12_u8(Vector_12_u8, size_t);
	4634
	4635	Vector_12_u8 c_ret_vector_12_u8(void) {
	4636	return (Vector_12_u8){ 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 };
	4637	}
	4638	void c_vector_12_u8(Vector_12_u8 v, size_t i) {
	4639	assert_or_panic(v[0] == 33);
	4640	assert_or_panic(v[1] == 34);
	4641	assert_or_panic(v[2] == 35);
	4642	assert_or_panic(v[3] == 36);
	4643	assert_or_panic(v[4] == 37);
	4644	assert_or_panic(v[5] == 38);
	4645	assert_or_panic(v[6] == 39);
	4646	assert_or_panic(v[7] == 40);
	4647	assert_or_panic(v[8] == 41);
	4648	assert_or_panic(v[9] == 42);
	4649	assert_or_panic(v[10] == 43);
	4650	assert_or_panic(v[11] == 44);
	4651	assert_or_panic(i == 12);
	4652	}
	4653	void c_test_vector_12_u8(void) {
	4654	Vector_12_u8 v = zig_ret_vector_12_u8();
	4655	assert_or_panic(v[0] == 97);
	4656	assert_or_panic(v[1] == 98);
	4657	assert_or_panic(v[2] == 99);
	4658	assert_or_panic(v[3] == 0);
	4659	assert_or_panic(v[4] == 1);
	4660	assert_or_panic(v[5] == 2);
	4661	assert_or_panic(v[6] == 3);
	4662	assert_or_panic(v[7] == 4);
	4663	assert_or_panic(v[8] == 5);
	4664	assert_or_panic(v[9] == 6);
	4665	assert_or_panic(v[10] == 7);
	4666	assert_or_panic(v[11] == 8);
	4667	zig_vector_12_u8((Vector_12_u8){ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 }, 12);
	4668	}
	4669
	4670	typedef uint8_t Vector_16_u8 __attribute__((vector_size(16 * sizeof(uint8_t))));
	4671
	4672	Vector_16_u8 zig_ret_vector_16_u8(void);
	4673	void zig_vector_16_u8(Vector_16_u8, size_t);
	4674
	4675	Vector_16_u8 c_ret_vector_16_u8(void) {
	4676	return (Vector_16_u8){ 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92 };
	4677	}
	4678	void c_vector_16_u8(Vector_16_u8 v, size_t i) {
	4679	assert_or_panic(v[0] == 93);
	4680	assert_or_panic(v[1] == 94);
	4681	assert_or_panic(v[2] == 95);
	4682	assert_or_panic(v[3] == 96);
	4683	assert_or_panic(v[4] == 97);
	4684	assert_or_panic(v[5] == 98);
	4685	assert_or_panic(v[6] == 99);
	4686	assert_or_panic(v[7] == 0);
	4687	assert_or_panic(v[8] == 1);
	4688	assert_or_panic(v[9] == 2);
	4689	assert_or_panic(v[10] == 3);
	4690	assert_or_panic(v[11] == 4);
	4691	assert_or_panic(v[12] == 5);
	4692	assert_or_panic(v[13] == 6);
	4693	assert_or_panic(v[14] == 7);
	4694	assert_or_panic(v[15] == 8);
	4695	assert_or_panic(i == 16);
	4696	}
	4697	void c_test_vector_16_u8(void) {
	4698	Vector_16_u8 v = zig_ret_vector_16_u8();
	4699	assert_or_panic(v[0] == 45);
	4700	assert_or_panic(v[1] == 46);
	4701	assert_or_panic(v[2] == 47);
	4702	assert_or_panic(v[3] == 48);
	4703	assert_or_panic(v[4] == 49);
	4704	assert_or_panic(v[5] == 50);
	4705	assert_or_panic(v[6] == 51);
	4706	assert_or_panic(v[7] == 52);
	4707	assert_or_panic(v[8] == 53);
	4708	assert_or_panic(v[9] == 54);
	4709	assert_or_panic(v[10] == 55);
	4710	assert_or_panic(v[11] == 56);
	4711	assert_or_panic(v[12] == 57);
	4712	assert_or_panic(v[13] == 58);
	4713	assert_or_panic(v[14] == 59);
	4714	assert_or_panic(v[15] == 60);
	4715	zig_vector_16_u8((Vector_16_u8){ 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76 }, 16);
	4716	}
	4717
	4718	typedef uint8_t Vector_24_u8 __attribute__((vector_size(24 * sizeof(uint8_t))));
	4719
	4720	Vector_24_u8 zig_ret_vector_24_u8(void);
	4721	void zig_vector_24_u8(Vector_24_u8, size_t);
	4722
	4723	Vector_24_u8 c_ret_vector_24_u8(void) {
	4724	return (Vector_24_u8){
	4725	57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
	4726	73, 74, 75, 76, 77, 78, 79, 80,
	4727	};
	4728	}
	4729	void c_vector_24_u8(Vector_24_u8 v, size_t i) {
	4730	assert_or_panic(v[0] == 81);
	4731	assert_or_panic(v[1] == 82);
	4732	assert_or_panic(v[2] == 83);
	4733	assert_or_panic(v[3] == 84);
	4734	assert_or_panic(v[4] == 85);
	4735	assert_or_panic(v[5] == 86);
	4736	assert_or_panic(v[6] == 87);
	4737	assert_or_panic(v[7] == 88);
	4738	assert_or_panic(v[8] == 89);
	4739	assert_or_panic(v[9] == 90);
	4740	assert_or_panic(v[10] == 91);
	4741	assert_or_panic(v[11] == 92);
	4742	assert_or_panic(v[12] == 93);
	4743	assert_or_panic(v[13] == 94);
	4744	assert_or_panic(v[14] == 95);
	4745	assert_or_panic(v[15] == 96);
	4746	assert_or_panic(v[16] == 97);
	4747	assert_or_panic(v[17] == 98);
	4748	assert_or_panic(v[18] == 99);
	4749	assert_or_panic(v[19] == 0);
	4750	assert_or_panic(v[20] == 1);
	4751	assert_or_panic(v[21] == 2);
	4752	assert_or_panic(v[22] == 3);
	4753	assert_or_panic(v[23] == 4);
	4754	assert_or_panic(i == 24);
	4755	}
	4756	void c_test_vector_24_u8(void) {
	4757	Vector_24_u8 v = zig_ret_vector_24_u8();
	4758	assert_or_panic(v[0] == 9);
	4759	assert_or_panic(v[1] == 10);
	4760	assert_or_panic(v[2] == 11);
	4761	assert_or_panic(v[3] == 12);
	4762	assert_or_panic(v[4] == 13);
	4763	assert_or_panic(v[5] == 14);
	4764	assert_or_panic(v[6] == 15);
	4765	assert_or_panic(v[7] == 16);
	4766	assert_or_panic(v[8] == 17);
	4767	assert_or_panic(v[9] == 18);
	4768	assert_or_panic(v[10] == 19);
	4769	assert_or_panic(v[11] == 20);
	4770	assert_or_panic(v[12] == 21);
	4771	assert_or_panic(v[13] == 22);
	4772	assert_or_panic(v[14] == 23);
	4773	assert_or_panic(v[15] == 24);
	4774	assert_or_panic(v[16] == 25);
	4775	assert_or_panic(v[17] == 26);
	4776	assert_or_panic(v[18] == 27);
	4777	assert_or_panic(v[19] == 28);
	4778	assert_or_panic(v[20] == 29);
	4779	assert_or_panic(v[21] == 30);
	4780	assert_or_panic(v[22] == 31);
	4781	assert_or_panic(v[23] == 32);
	4782	zig_vector_24_u8((Vector_24_u8){
	4783	33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
	4784	49, 50, 51, 52, 53, 54, 55, 56,
	4785	}, 24);
	4786	}
	4787
	4788	typedef uint8_t Vector_32_u8 __attribute__((vector_size(32 * sizeof(uint8_t))));
	4789
	4790	Vector_32_u8 zig_ret_vector_32_u8(void);
	4791	void zig_vector_32_u8(Vector_32_u8, size_t);
	4792
	4793	Vector_32_u8 c_ret_vector_32_u8(void) {
	4794	return (Vector_32_u8){
	4795	69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
	4796	85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0,
	4797	};
	4798	}
	4799	void c_vector_32_u8(Vector_32_u8 v, size_t i) {
	4800	assert_or_panic(v[0] == 1);
	4801	assert_or_panic(v[1] == 2);
	4802	assert_or_panic(v[2] == 3);
	4803	assert_or_panic(v[3] == 4);
	4804	assert_or_panic(v[4] == 5);
	4805	assert_or_panic(v[5] == 6);
	4806	assert_or_panic(v[6] == 7);
	4807	assert_or_panic(v[7] == 8);
	4808	assert_or_panic(v[8] == 9);
	4809	assert_or_panic(v[9] == 10);
	4810	assert_or_panic(v[10] == 11);
	4811	assert_or_panic(v[11] == 12);
	4812	assert_or_panic(v[12] == 13);
	4813	assert_or_panic(v[13] == 14);
	4814	assert_or_panic(v[14] == 15);
	4815	assert_or_panic(v[15] == 16);
	4816	assert_or_panic(v[16] == 17);
	4817	assert_or_panic(v[17] == 18);
	4818	assert_or_panic(v[18] == 19);
	4819	assert_or_panic(v[19] == 20);
	4820	assert_or_panic(v[20] == 21);
	4821	assert_or_panic(v[21] == 22);
	4822	assert_or_panic(v[22] == 23);
	4823	assert_or_panic(v[23] == 24);
	4824	assert_or_panic(v[24] == 25);
	4825	assert_or_panic(v[25] == 26);
	4826	assert_or_panic(v[26] == 27);
	4827	assert_or_panic(v[27] == 28);
	4828	assert_or_panic(v[28] == 29);
	4829	assert_or_panic(v[29] == 30);
	4830	assert_or_panic(v[30] == 31);
	4831	assert_or_panic(v[31] == 32);
	4832	assert_or_panic(i == 32);
	4833	}
	4834	void c_test_vector_32_u8(void) {
	4835	Vector_32_u8 v = zig_ret_vector_32_u8();
	4836	assert_or_panic(v[0] == 5);
	4837	assert_or_panic(v[1] == 6);
	4838	assert_or_panic(v[2] == 7);
	4839	assert_or_panic(v[3] == 8);
	4840	assert_or_panic(v[4] == 9);
	4841	assert_or_panic(v[5] == 10);
	4842	assert_or_panic(v[6] == 11);
	4843	assert_or_panic(v[7] == 12);
	4844	assert_or_panic(v[8] == 13);
	4845	assert_or_panic(v[9] == 14);
	4846	assert_or_panic(v[10] == 15);
	4847	assert_or_panic(v[11] == 16);
	4848	assert_or_panic(v[12] == 17);
	4849	assert_or_panic(v[13] == 18);
	4850	assert_or_panic(v[14] == 19);
	4851	assert_or_panic(v[15] == 20);
	4852	assert_or_panic(v[16] == 21);
	4853	assert_or_panic(v[17] == 22);
	4854	assert_or_panic(v[18] == 23);
	4855	assert_or_panic(v[19] == 24);
	4856	assert_or_panic(v[20] == 25);
	4857	assert_or_panic(v[21] == 26);
	4858	assert_or_panic(v[22] == 27);
	4859	assert_or_panic(v[23] == 28);
	4860	assert_or_panic(v[24] == 29);
	4861	assert_or_panic(v[25] == 30);
	4862	assert_or_panic(v[26] == 31);
	4863	assert_or_panic(v[27] == 32);
	4864	assert_or_panic(v[28] == 33);
	4865	assert_or_panic(v[29] == 34);
	4866	assert_or_panic(v[30] == 35);
	4867	assert_or_panic(v[31] == 36);
	4868	zig_vector_32_u8((Vector_32_u8){
	4869	37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
	4870	53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
	4871	}, 32);
	4872	}
	4873
	4874	typedef uint8_t Vector_48_u8 __attribute__((vector_size(48 * sizeof(uint8_t))));
	4875
	4876	Vector_48_u8 zig_ret_vector_48_u8(void);
	4877	void zig_vector_48_u8(Vector_48_u8, size_t);
	4878
	4879	Vector_48_u8 c_ret_vector_48_u8(void) {
	4880	return (Vector_48_u8){
	4881	29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
	4882	45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
	4883	61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
	4884	};
	4885	}
	4886	void c_vector_48_u8(Vector_48_u8 v, size_t i) {
	4887	assert_or_panic(v[0] == 77);
	4888	assert_or_panic(v[1] == 78);
	4889	assert_or_panic(v[2] == 79);
	4890	assert_or_panic(v[3] == 80);
	4891	assert_or_panic(v[4] == 81);
	4892	assert_or_panic(v[5] == 82);
	4893	assert_or_panic(v[6] == 83);
	4894	assert_or_panic(v[7] == 84);
	4895	assert_or_panic(v[8] == 85);
	4896	assert_or_panic(v[9] == 86);
	4897	assert_or_panic(v[10] == 87);
	4898	assert_or_panic(v[11] == 88);
	4899	assert_or_panic(v[12] == 89);
	4900	assert_or_panic(v[13] == 90);
	4901	assert_or_panic(v[14] == 91);
	4902	assert_or_panic(v[15] == 92);
	4903	assert_or_panic(v[16] == 93);
	4904	assert_or_panic(v[17] == 94);
	4905	assert_or_panic(v[18] == 95);
	4906	assert_or_panic(v[19] == 96);
	4907	assert_or_panic(v[20] == 97);
	4908	assert_or_panic(v[21] == 98);
	4909	assert_or_panic(v[22] == 99);
	4910	assert_or_panic(v[23] == 0);
	4911	assert_or_panic(v[24] == 1);
	4912	assert_or_panic(v[25] == 2);
	4913	assert_or_panic(v[26] == 3);
	4914	assert_or_panic(v[27] == 4);
	4915	assert_or_panic(v[28] == 5);
	4916	assert_or_panic(v[29] == 6);
	4917	assert_or_panic(v[30] == 7);
	4918	assert_or_panic(v[31] == 8);
	4919	assert_or_panic(v[32] == 9);
	4920	assert_or_panic(v[33] == 10);
	4921	assert_or_panic(v[34] == 11);
	4922	assert_or_panic(v[35] == 12);
	4923	assert_or_panic(v[36] == 13);
	4924	assert_or_panic(v[37] == 14);
	4925	assert_or_panic(v[38] == 15);
	4926	assert_or_panic(v[39] == 16);
	4927	assert_or_panic(v[40] == 17);
	4928	assert_or_panic(v[41] == 18);
	4929	assert_or_panic(v[42] == 19);
	4930	assert_or_panic(v[43] == 20);
	4931	assert_or_panic(v[44] == 21);
	4932	assert_or_panic(v[45] == 22);
	4933	assert_or_panic(v[46] == 23);
	4934	assert_or_panic(v[47] == 24);
	4935	assert_or_panic(i == 48);
	4936	}
	4937	void c_test_vector_48_u8(void) {
	4938	Vector_48_u8 v = zig_ret_vector_48_u8();
	4939	assert_or_panic(v[0] == 33);
	4940	assert_or_panic(v[1] == 34);
	4941	assert_or_panic(v[2] == 35);
	4942	assert_or_panic(v[3] == 36);
	4943	assert_or_panic(v[4] == 37);
	4944	assert_or_panic(v[5] == 38);
	4945	assert_or_panic(v[6] == 39);
	4946	assert_or_panic(v[7] == 40);
	4947	assert_or_panic(v[8] == 41);
	4948	assert_or_panic(v[9] == 42);
	4949	assert_or_panic(v[10] == 43);
	4950	assert_or_panic(v[11] == 44);
	4951	assert_or_panic(v[12] == 45);
	4952	assert_or_panic(v[13] == 46);
	4953	assert_or_panic(v[14] == 47);
	4954	assert_or_panic(v[15] == 48);
	4955	assert_or_panic(v[16] == 49);
	4956	assert_or_panic(v[17] == 50);
	4957	assert_or_panic(v[18] == 51);
	4958	assert_or_panic(v[19] == 52);
	4959	assert_or_panic(v[20] == 53);
	4960	assert_or_panic(v[21] == 54);
	4961	assert_or_panic(v[22] == 55);
	4962	assert_or_panic(v[23] == 56);
	4963	assert_or_panic(v[24] == 57);
	4964	assert_or_panic(v[25] == 58);
	4965	assert_or_panic(v[26] == 59);
	4966	assert_or_panic(v[27] == 60);
	4967	assert_or_panic(v[28] == 61);
	4968	assert_or_panic(v[29] == 62);
	4969	assert_or_panic(v[30] == 63);
	4970	assert_or_panic(v[31] == 64);
	4971	assert_or_panic(v[32] == 65);
	4972	assert_or_panic(v[33] == 66);
	4973	assert_or_panic(v[34] == 67);
	4974	assert_or_panic(v[35] == 68);
	4975	assert_or_panic(v[36] == 69);
	4976	assert_or_panic(v[37] == 70);
	4977	assert_or_panic(v[38] == 71);
	4978	assert_or_panic(v[39] == 72);
	4979	assert_or_panic(v[40] == 73);
	4980	assert_or_panic(v[41] == 74);
	4981	assert_or_panic(v[42] == 75);
	4982	assert_or_panic(v[43] == 76);
	4983	assert_or_panic(v[44] == 77);
	4984	assert_or_panic(v[45] == 78);
	4985	assert_or_panic(v[46] == 79);
	4986	assert_or_panic(v[47] == 80);
	4987	zig_vector_48_u8((Vector_48_u8){
	4988	81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
	4989	97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
	4990	13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
	4991	}, 48);
	4992	}
	4993
	4994	typedef uint8_t Vector_64_u8 __attribute__((vector_size(64 * sizeof(uint8_t))));
	4995
	4996	Vector_64_u8 zig_ret_vector_64_u8(void);
	4997	void zig_vector_64_u8(Vector_64_u8, size_t);
	4998
	4999	Vector_64_u8 c_ret_vector_64_u8(void) {
	5000	return (Vector_64_u8){
	5001	53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
	5002	69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
	5003	85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0,
	5004	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
	5005	};
	5006	}
	5007	void c_vector_64_u8(Vector_64_u8 v, size_t i) {
	5008	assert_or_panic(v[0] == 17);
	5009	assert_or_panic(v[1] == 18);
	5010	assert_or_panic(v[2] == 19);
	5011	assert_or_panic(v[3] == 20);
	5012	assert_or_panic(v[4] == 21);
	5013	assert_or_panic(v[5] == 22);
	5014	assert_or_panic(v[6] == 23);
	5015	assert_or_panic(v[7] == 24);
	5016	assert_or_panic(v[8] == 25);
	5017	assert_or_panic(v[9] == 26);
	5018	assert_or_panic(v[10] == 27);
	5019	assert_or_panic(v[11] == 28);
	5020	assert_or_panic(v[12] == 29);
	5021	assert_or_panic(v[13] == 30);
	5022	assert_or_panic(v[14] == 31);
	5023	assert_or_panic(v[15] == 32);
	5024	assert_or_panic(v[16] == 33);
	5025	assert_or_panic(v[17] == 34);
	5026	assert_or_panic(v[18] == 35);
	5027	assert_or_panic(v[19] == 36);
	5028	assert_or_panic(v[20] == 37);
	5029	assert_or_panic(v[21] == 38);
	5030	assert_or_panic(v[22] == 39);
	5031	assert_or_panic(v[23] == 40);
	5032	assert_or_panic(v[24] == 41);
	5033	assert_or_panic(v[25] == 42);
	5034	assert_or_panic(v[26] == 43);
	5035	assert_or_panic(v[27] == 44);
	5036	assert_or_panic(v[28] == 45);
	5037	assert_or_panic(v[29] == 46);
	5038	assert_or_panic(v[30] == 47);
	5039	assert_or_panic(v[31] == 48);
	5040	assert_or_panic(v[32] == 49);
	5041	assert_or_panic(v[33] == 50);
	5042	assert_or_panic(v[34] == 51);
	5043	assert_or_panic(v[35] == 52);
	5044	assert_or_panic(v[36] == 53);
	5045	assert_or_panic(v[37] == 54);
	5046	assert_or_panic(v[38] == 55);
	5047	assert_or_panic(v[39] == 56);
	5048	assert_or_panic(v[40] == 57);
	5049	assert_or_panic(v[41] == 58);
	5050	assert_or_panic(v[42] == 59);
	5051	assert_or_panic(v[43] == 60);
	5052	assert_or_panic(v[44] == 61);
	5053	assert_or_panic(v[45] == 62);
	5054	assert_or_panic(v[46] == 63);
	5055	assert_or_panic(v[47] == 64);
	5056	assert_or_panic(v[48] == 65);
	5057	assert_or_panic(v[49] == 66);
	5058	assert_or_panic(v[50] == 67);
	5059	assert_or_panic(v[51] == 68);
	5060	assert_or_panic(v[52] == 69);
	5061	assert_or_panic(v[53] == 70);
	5062	assert_or_panic(v[54] == 71);
	5063	assert_or_panic(v[55] == 72);
	5064	assert_or_panic(v[56] == 73);
	5065	assert_or_panic(v[57] == 74);
	5066	assert_or_panic(v[58] == 75);
	5067	assert_or_panic(v[59] == 76);
	5068	assert_or_panic(v[60] == 77);
	5069	assert_or_panic(v[61] == 78);
	5070	assert_or_panic(v[62] == 79);
	5071	assert_or_panic(v[63] == 80);
	5072	assert_or_panic(i == 64);
	5073	}
	5074	void c_test_vector_64_u8(void) {
	5075	Vector_64_u8 v = zig_ret_vector_64_u8();
	5076	assert_or_panic(v[0] == 25);
	5077	assert_or_panic(v[1] == 26);
	5078	assert_or_panic(v[2] == 27);
	5079	assert_or_panic(v[3] == 28);
	5080	assert_or_panic(v[4] == 29);
	5081	assert_or_panic(v[5] == 30);
	5082	assert_or_panic(v[6] == 31);
	5083	assert_or_panic(v[7] == 32);
	5084	assert_or_panic(v[8] == 33);
	5085	assert_or_panic(v[9] == 34);
	5086	assert_or_panic(v[10] == 35);
	5087	assert_or_panic(v[11] == 36);
	5088	assert_or_panic(v[12] == 37);
	5089	assert_or_panic(v[13] == 38);
	5090	assert_or_panic(v[14] == 39);
	5091	assert_or_panic(v[15] == 40);
	5092	assert_or_panic(v[16] == 41);
	5093	assert_or_panic(v[17] == 42);
	5094	assert_or_panic(v[18] == 43);
	5095	assert_or_panic(v[19] == 44);
	5096	assert_or_panic(v[20] == 45);
	5097	assert_or_panic(v[21] == 46);
	5098	assert_or_panic(v[22] == 47);
	5099	assert_or_panic(v[23] == 48);
	5100	assert_or_panic(v[24] == 49);
	5101	assert_or_panic(v[25] == 50);
	5102	assert_or_panic(v[26] == 51);
	5103	assert_or_panic(v[27] == 52);
	5104	assert_or_panic(v[28] == 53);
	5105	assert_or_panic(v[29] == 54);
	5106	assert_or_panic(v[30] == 55);
	5107	assert_or_panic(v[31] == 56);
	5108	assert_or_panic(v[32] == 57);
	5109	assert_or_panic(v[33] == 58);
	5110	assert_or_panic(v[34] == 59);
	5111	assert_or_panic(v[35] == 60);
	5112	assert_or_panic(v[36] == 61);
	5113	assert_or_panic(v[37] == 62);
	5114	assert_or_panic(v[38] == 63);
	5115	assert_or_panic(v[39] == 64);
	5116	assert_or_panic(v[40] == 65);
	5117	assert_or_panic(v[41] == 66);
	5118	assert_or_panic(v[42] == 67);
	5119	assert_or_panic(v[43] == 68);
	5120	assert_or_panic(v[44] == 69);
	5121	assert_or_panic(v[45] == 70);
	5122	assert_or_panic(v[46] == 71);
	5123	assert_or_panic(v[47] == 72);
	5124	assert_or_panic(v[48] == 73);
	5125	assert_or_panic(v[49] == 74);
	5126	assert_or_panic(v[50] == 75);
	5127	assert_or_panic(v[51] == 76);
	5128	assert_or_panic(v[52] == 77);
	5129	assert_or_panic(v[53] == 78);
	5130	assert_or_panic(v[54] == 79);
	5131	assert_or_panic(v[55] == 80);
	5132	assert_or_panic(v[56] == 81);
	5133	assert_or_panic(v[57] == 82);
	5134	assert_or_panic(v[58] == 83);
	5135	assert_or_panic(v[59] == 84);
	5136	assert_or_panic(v[60] == 85);
	5137	assert_or_panic(v[61] == 86);
	5138	assert_or_panic(v[62] == 87);
	5139	assert_or_panic(v[63] == 88);
	5140	zig_vector_64_u8((Vector_64_u8){
	5141	89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4,
	5142	5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
	5143	21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
	5144	37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
	5145	}, 64);
	5146	}
	5147
	5148	typedef uint8_t Vector_96_u8 __attribute__((vector_size(96 * sizeof(uint8_t))));
	5149
	5150	Vector_96_u8 zig_ret_vector_96_u8(void);
	5151	void zig_vector_96_u8(Vector_96_u8, size_t);
	5152
	5153	Vector_96_u8 c_ret_vector_96_u8(void) {
	5154	return (Vector_96_u8){
	5155	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	5156	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	5157	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	5158	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	5159	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	5160	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	5161	};
	5162	}
	5163	void c_vector_96_u8(Vector_96_u8 v, size_t i) {
	5164	assert_or_panic(v[0] == 78);
	5165	assert_or_panic(v[1] == 79);
	5166	assert_or_panic(v[2] == 80);
	5167	assert_or_panic(v[3] == 81);
	5168	assert_or_panic(v[4] == 82);
	5169	assert_or_panic(v[5] == 83);
	5170	assert_or_panic(v[6] == 84);
	5171	assert_or_panic(v[7] == 85);
	5172	assert_or_panic(v[8] == 86);
	5173	assert_or_panic(v[9] == 87);
	5174	assert_or_panic(v[10] == 88);
	5175	assert_or_panic(v[11] == 89);
	5176	assert_or_panic(v[12] == 90);
	5177	assert_or_panic(v[13] == 91);
	5178	assert_or_panic(v[14] == 92);
	5179	assert_or_panic(v[15] == 93);
	5180	assert_or_panic(v[16] == 94);
	5181	assert_or_panic(v[17] == 95);
	5182	assert_or_panic(v[18] == 96);
	5183	assert_or_panic(v[19] == 97);
	5184	assert_or_panic(v[20] == 98);
	5185	assert_or_panic(v[21] == 99);
	5186	assert_or_panic(v[22] == 0);
	5187	assert_or_panic(v[23] == 1);
	5188	assert_or_panic(v[24] == 2);
	5189	assert_or_panic(v[25] == 3);
	5190	assert_or_panic(v[26] == 4);
	5191	assert_or_panic(v[27] == 5);
	5192	assert_or_panic(v[28] == 6);
	5193	assert_or_panic(v[29] == 7);
	5194	assert_or_panic(v[30] == 8);
	5195	assert_or_panic(v[31] == 9);
	5196	assert_or_panic(v[32] == 10);
	5197	assert_or_panic(v[33] == 11);
	5198	assert_or_panic(v[34] == 12);
	5199	assert_or_panic(v[35] == 13);
	5200	assert_or_panic(v[36] == 14);
	5201	assert_or_panic(v[37] == 15);
	5202	assert_or_panic(v[38] == 16);
	5203	assert_or_panic(v[39] == 17);
	5204	assert_or_panic(v[40] == 18);
	5205	assert_or_panic(v[41] == 19);
	5206	assert_or_panic(v[42] == 20);
	5207	assert_or_panic(v[43] == 21);
	5208	assert_or_panic(v[44] == 22);
	5209	assert_or_panic(v[45] == 23);
	5210	assert_or_panic(v[46] == 24);
	5211	assert_or_panic(v[47] == 25);
	5212	assert_or_panic(v[48] == 26);
	5213	assert_or_panic(v[49] == 27);
	5214	assert_or_panic(v[50] == 28);
	5215	assert_or_panic(v[51] == 29);
	5216	assert_or_panic(v[52] == 30);
	5217	assert_or_panic(v[53] == 31);
	5218	assert_or_panic(v[54] == 32);
	5219	assert_or_panic(v[55] == 33);
	5220	assert_or_panic(v[56] == 34);
	5221	assert_or_panic(v[57] == 35);
	5222	assert_or_panic(v[58] == 36);
	5223	assert_or_panic(v[59] == 37);
	5224	assert_or_panic(v[60] == 38);
	5225	assert_or_panic(v[61] == 39);
	5226	assert_or_panic(v[62] == 40);
	5227	assert_or_panic(v[63] == 41);
	5228	assert_or_panic(v[64] == 42);
	5229	assert_or_panic(v[65] == 43);
	5230	assert_or_panic(v[66] == 44);
	5231	assert_or_panic(v[67] == 45);
	5232	assert_or_panic(v[68] == 46);
	5233	assert_or_panic(v[69] == 47);
	5234	assert_or_panic(v[70] == 48);
	5235	assert_or_panic(v[71] == 49);
	5236	assert_or_panic(v[72] == 50);
	5237	assert_or_panic(v[73] == 51);
	5238	assert_or_panic(v[74] == 52);
	5239	assert_or_panic(v[75] == 53);
	5240	assert_or_panic(v[76] == 54);
	5241	assert_or_panic(v[77] == 55);
	5242	assert_or_panic(v[80] == 58);
	5243	assert_or_panic(v[81] == 59);
	5244	assert_or_panic(v[82] == 60);
	5245	assert_or_panic(v[83] == 61);
	5246	assert_or_panic(v[84] == 62);
	5247	assert_or_panic(v[85] == 63);
	5248	assert_or_panic(v[86] == 64);
	5249	assert_or_panic(v[87] == 65);
	5250	assert_or_panic(v[88] == 66);
	5251	assert_or_panic(v[89] == 67);
	5252	assert_or_panic(v[90] == 68);
	5253	assert_or_panic(v[91] == 69);
	5254	assert_or_panic(v[92] == 70);
	5255	assert_or_panic(v[93] == 71);
	5256	assert_or_panic(v[94] == 72);
	5257	assert_or_panic(v[95] == 73);
	5258	assert_or_panic(i == 96);
	5259	}
	5260	void c_test_vector_96_u8(void) {
	5261	Vector_96_u8 v = zig_ret_vector_96_u8();
	5262	assert_or_panic(v[0] == 90);
	5263	assert_or_panic(v[1] == 91);
	5264	assert_or_panic(v[2] == 92);
	5265	assert_or_panic(v[3] == 93);
	5266	assert_or_panic(v[4] == 94);
	5267	assert_or_panic(v[5] == 95);
	5268	assert_or_panic(v[6] == 96);
	5269	assert_or_panic(v[7] == 97);
	5270	assert_or_panic(v[8] == 98);
	5271	assert_or_panic(v[9] == 99);
	5272	assert_or_panic(v[10] == 0);
	5273	assert_or_panic(v[11] == 1);
	5274	assert_or_panic(v[12] == 2);
	5275	assert_or_panic(v[13] == 3);
	5276	assert_or_panic(v[14] == 4);
	5277	assert_or_panic(v[15] == 5);
	5278	assert_or_panic(v[16] == 6);
	5279	assert_or_panic(v[17] == 7);
	5280	assert_or_panic(v[18] == 8);
	5281	assert_or_panic(v[19] == 9);
	5282	assert_or_panic(v[20] == 10);
	5283	assert_or_panic(v[21] == 11);
	5284	assert_or_panic(v[22] == 12);
	5285	assert_or_panic(v[23] == 13);
	5286	assert_or_panic(v[24] == 14);
	5287	assert_or_panic(v[25] == 15);
	5288	assert_or_panic(v[26] == 16);
	5289	assert_or_panic(v[27] == 17);
	5290	assert_or_panic(v[28] == 18);
	5291	assert_or_panic(v[29] == 19);
	5292	assert_or_panic(v[30] == 20);
	5293	assert_or_panic(v[31] == 21);
	5294	assert_or_panic(v[32] == 22);
	5295	assert_or_panic(v[33] == 23);
	5296	assert_or_panic(v[34] == 24);
	5297	assert_or_panic(v[35] == 25);
	5298	assert_or_panic(v[36] == 26);
	5299	assert_or_panic(v[37] == 27);
	5300	assert_or_panic(v[38] == 28);
	5301	assert_or_panic(v[39] == 29);
	5302	assert_or_panic(v[40] == 30);
	5303	assert_or_panic(v[41] == 31);
	5304	assert_or_panic(v[42] == 32);
	5305	assert_or_panic(v[43] == 33);
	5306	assert_or_panic(v[44] == 34);
	5307	assert_or_panic(v[45] == 35);
	5308	assert_or_panic(v[46] == 36);
	5309	assert_or_panic(v[47] == 37);
	5310	assert_or_panic(v[48] == 38);
	5311	assert_or_panic(v[49] == 39);
	5312	assert_or_panic(v[50] == 40);
	5313	assert_or_panic(v[51] == 41);
	5314	assert_or_panic(v[52] == 42);
	5315	assert_or_panic(v[53] == 43);
	5316	assert_or_panic(v[54] == 44);
	5317	assert_or_panic(v[55] == 45);
	5318	assert_or_panic(v[56] == 46);
	5319	assert_or_panic(v[57] == 47);
	5320	assert_or_panic(v[58] == 48);
	5321	assert_or_panic(v[59] == 49);
	5322	assert_or_panic(v[60] == 50);
	5323	assert_or_panic(v[61] == 51);
	5324	assert_or_panic(v[62] == 52);
	5325	assert_or_panic(v[63] == 53);
	5326	assert_or_panic(v[64] == 54);
	5327	assert_or_panic(v[65] == 55);
	5328	assert_or_panic(v[66] == 56);
	5329	assert_or_panic(v[67] == 57);
	5330	assert_or_panic(v[68] == 58);
	5331	assert_or_panic(v[69] == 59);
	5332	assert_or_panic(v[70] == 60);
	5333	assert_or_panic(v[71] == 61);
	5334	assert_or_panic(v[72] == 62);
	5335	assert_or_panic(v[73] == 63);
	5336	assert_or_panic(v[74] == 64);
	5337	assert_or_panic(v[75] == 65);
	5338	assert_or_panic(v[76] == 66);
	5339	assert_or_panic(v[77] == 67);
	5340	assert_or_panic(v[78] == 68);
	5341	assert_or_panic(v[79] == 69);
	5342	assert_or_panic(v[80] == 70);
	5343	assert_or_panic(v[81] == 71);
	5344	assert_or_panic(v[82] == 72);
	5345	assert_or_panic(v[83] == 73);
	5346	assert_or_panic(v[84] == 74);
	5347	assert_or_panic(v[85] == 75);
	5348	assert_or_panic(v[86] == 76);
	5349	assert_or_panic(v[87] == 77);
	5350	assert_or_panic(v[88] == 78);
	5351	assert_or_panic(v[89] == 79);
	5352	assert_or_panic(v[90] == 80);
	5353	assert_or_panic(v[91] == 81);
	5354	assert_or_panic(v[92] == 82);
	5355	assert_or_panic(v[93] == 83);
	5356	assert_or_panic(v[94] == 84);
	5357	assert_or_panic(v[95] == 85);
	5358	zig_vector_96_u8((Vector_96_u8){
	5359	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	5360	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	5361	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	5362	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	5363	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	5364	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	5365	}, 96);
	5366	}
	5367
	5368	typedef uint8_t Vector_128_u8 __attribute__((vector_size(128 * sizeof(uint8_t))));
	5369
	5370	Vector_128_u8 zig_ret_vector_128_u8(void);
	5371	void zig_vector_128_u8(Vector_128_u8, size_t);
	5372
	5373	Vector_128_u8 c_ret_vector_128_u8(void) {
	5374	return (Vector_128_u8){
	5375	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	5376	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	5377	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	5378	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	5379	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	5380	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	5381	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	5382	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	5383	};
	5384	}
	5385	void c_vector_128_u8(Vector_128_u8 v, size_t i) {
	5386	assert_or_panic(v[0] == 58);
	5387	assert_or_panic(v[1] == 59);
	5388	assert_or_panic(v[2] == 60);
	5389	assert_or_panic(v[3] == 61);
	5390	assert_or_panic(v[4] == 62);
	5391	assert_or_panic(v[5] == 63);
	5392	assert_or_panic(v[6] == 64);
	5393	assert_or_panic(v[7] == 65);
	5394	assert_or_panic(v[8] == 66);
	5395	assert_or_panic(v[9] == 67);
	5396	assert_or_panic(v[10] == 68);
	5397	assert_or_panic(v[11] == 69);
	5398	assert_or_panic(v[12] == 70);
	5399	assert_or_panic(v[13] == 71);
	5400	assert_or_panic(v[14] == 72);
	5401	assert_or_panic(v[15] == 73);
	5402	assert_or_panic(v[16] == 74);
	5403	assert_or_panic(v[17] == 75);
	5404	assert_or_panic(v[18] == 76);
	5405	assert_or_panic(v[19] == 77);
	5406	assert_or_panic(v[20] == 78);
	5407	assert_or_panic(v[21] == 79);
	5408	assert_or_panic(v[22] == 80);
	5409	assert_or_panic(v[23] == 81);
	5410	assert_or_panic(v[24] == 82);
	5411	assert_or_panic(v[25] == 83);
	5412	assert_or_panic(v[26] == 84);
	5413	assert_or_panic(v[27] == 85);
	5414	assert_or_panic(v[28] == 86);
	5415	assert_or_panic(v[29] == 87);
	5416	assert_or_panic(v[30] == 88);
	5417	assert_or_panic(v[31] == 89);
	5418	assert_or_panic(v[32] == 90);
	5419	assert_or_panic(v[33] == 91);
	5420	assert_or_panic(v[34] == 92);
	5421	assert_or_panic(v[35] == 93);
	5422	assert_or_panic(v[36] == 94);
	5423	assert_or_panic(v[37] == 95);
	5424	assert_or_panic(v[38] == 96);
	5425	assert_or_panic(v[39] == 97);
	5426	assert_or_panic(v[40] == 98);
	5427	assert_or_panic(v[41] == 99);
	5428	assert_or_panic(v[42] == 0);
	5429	assert_or_panic(v[43] == 1);
	5430	assert_or_panic(v[44] == 2);
	5431	assert_or_panic(v[45] == 3);
	5432	assert_or_panic(v[46] == 4);
	5433	assert_or_panic(v[47] == 5);
	5434	assert_or_panic(v[48] == 6);
	5435	assert_or_panic(v[49] == 7);
	5436	assert_or_panic(v[50] == 8);
	5437	assert_or_panic(v[51] == 9);
	5438	assert_or_panic(v[52] == 10);
	5439	assert_or_panic(v[53] == 11);
	5440	assert_or_panic(v[54] == 12);
	5441	assert_or_panic(v[55] == 13);
	5442	assert_or_panic(v[56] == 14);
	5443	assert_or_panic(v[57] == 15);
	5444	assert_or_panic(v[58] == 16);
	5445	assert_or_panic(v[59] == 17);
	5446	assert_or_panic(v[60] == 18);
	5447	assert_or_panic(v[61] == 19);
	5448	assert_or_panic(v[62] == 20);
	5449	assert_or_panic(v[63] == 21);
	5450	assert_or_panic(v[64] == 22);
	5451	assert_or_panic(v[65] == 23);
	5452	assert_or_panic(v[66] == 24);
	5453	assert_or_panic(v[67] == 25);
	5454	assert_or_panic(v[68] == 26);
	5455	assert_or_panic(v[69] == 27);
	5456	assert_or_panic(v[70] == 28);
	5457	assert_or_panic(v[71] == 29);
	5458	assert_or_panic(v[72] == 30);
	5459	assert_or_panic(v[73] == 31);
	5460	assert_or_panic(v[74] == 32);
	5461	assert_or_panic(v[75] == 33);
	5462	assert_or_panic(v[76] == 34);
	5463	assert_or_panic(v[77] == 35);
	5464	assert_or_panic(v[78] == 36);
	5465	assert_or_panic(v[79] == 37);
	5466	assert_or_panic(v[80] == 38);
	5467	assert_or_panic(v[81] == 39);
	5468	assert_or_panic(v[82] == 40);
	5469	assert_or_panic(v[83] == 41);
	5470	assert_or_panic(v[84] == 42);
	5471	assert_or_panic(v[85] == 43);
	5472	assert_or_panic(v[86] == 44);
	5473	assert_or_panic(v[87] == 45);
	5474	assert_or_panic(v[88] == 46);
	5475	assert_or_panic(v[89] == 47);
	5476	assert_or_panic(v[90] == 48);
	5477	assert_or_panic(v[91] == 49);
	5478	assert_or_panic(v[92] == 50);
	5479	assert_or_panic(v[93] == 51);
	5480	assert_or_panic(v[94] == 52);
	5481	assert_or_panic(v[95] == 53);
	5482	assert_or_panic(v[96] == 54);
	5483	assert_or_panic(v[97] == 55);
	5484	assert_or_panic(v[98] == 56);
	5485	assert_or_panic(v[99] == 57);
	5486	assert_or_panic(v[100] == 58);
	5487	assert_or_panic(v[101] == 59);
	5488	assert_or_panic(v[102] == 60);
	5489	assert_or_panic(v[103] == 61);
	5490	assert_or_panic(v[104] == 62);
	5491	assert_or_panic(v[105] == 63);
	5492	assert_or_panic(v[106] == 64);
	5493	assert_or_panic(v[107] == 65);
	5494	assert_or_panic(v[108] == 66);
	5495	assert_or_panic(v[109] == 67);
	5496	assert_or_panic(v[110] == 68);
	5497	assert_or_panic(v[111] == 69);
	5498	assert_or_panic(v[112] == 70);
	5499	assert_or_panic(v[113] == 71);
	5500	assert_or_panic(v[114] == 72);
	5501	assert_or_panic(v[115] == 73);
	5502	assert_or_panic(v[116] == 74);
	5503	assert_or_panic(v[117] == 75);
	5504	assert_or_panic(v[118] == 76);
	5505	assert_or_panic(v[119] == 77);
	5506	assert_or_panic(v[120] == 78);
	5507	assert_or_panic(v[121] == 79);
	5508	assert_or_panic(v[122] == 80);
	5509	assert_or_panic(v[123] == 81);
	5510	assert_or_panic(v[124] == 82);
	5511	assert_or_panic(v[125] == 83);
	5512	assert_or_panic(v[126] == 84);
	5513	assert_or_panic(v[127] == 85);
	5514	assert_or_panic(i == 128);
	5515	}
	5516	void c_test_vector_128_u8(void) {
	5517	Vector_128_u8 v = zig_ret_vector_128_u8();
	5518	assert_or_panic(v[0] == 74);
	5519	assert_or_panic(v[1] == 75);
	5520	assert_or_panic(v[2] == 76);
	5521	assert_or_panic(v[3] == 77);
	5522	assert_or_panic(v[4] == 78);
	5523	assert_or_panic(v[5] == 79);
	5524	assert_or_panic(v[6] == 80);
	5525	assert_or_panic(v[7] == 81);
	5526	assert_or_panic(v[8] == 82);
	5527	assert_or_panic(v[9] == 83);
	5528	assert_or_panic(v[10] == 84);
	5529	assert_or_panic(v[11] == 85);
	5530	assert_or_panic(v[12] == 86);
	5531	assert_or_panic(v[13] == 87);
	5532	assert_or_panic(v[14] == 88);
	5533	assert_or_panic(v[15] == 89);
	5534	assert_or_panic(v[16] == 90);
	5535	assert_or_panic(v[17] == 91);
	5536	assert_or_panic(v[18] == 92);
	5537	assert_or_panic(v[19] == 93);
	5538	assert_or_panic(v[20] == 94);
	5539	assert_or_panic(v[21] == 95);
	5540	assert_or_panic(v[22] == 96);
	5541	assert_or_panic(v[23] == 97);
	5542	assert_or_panic(v[24] == 98);
	5543	assert_or_panic(v[25] == 99);
	5544	assert_or_panic(v[26] == 0);
	5545	assert_or_panic(v[27] == 1);
	5546	assert_or_panic(v[28] == 2);
	5547	assert_or_panic(v[29] == 3);
	5548	assert_or_panic(v[30] == 4);
	5549	assert_or_panic(v[31] == 5);
	5550	assert_or_panic(v[32] == 6);
	5551	assert_or_panic(v[33] == 7);
	5552	assert_or_panic(v[34] == 8);
	5553	assert_or_panic(v[35] == 9);
	5554	assert_or_panic(v[36] == 10);
	5555	assert_or_panic(v[37] == 11);
	5556	assert_or_panic(v[38] == 12);
	5557	assert_or_panic(v[39] == 13);
	5558	assert_or_panic(v[40] == 14);
	5559	assert_or_panic(v[41] == 15);
	5560	assert_or_panic(v[42] == 16);
	5561	assert_or_panic(v[43] == 17);
	5562	assert_or_panic(v[44] == 18);
	5563	assert_or_panic(v[45] == 19);
	5564	assert_or_panic(v[46] == 20);
	5565	assert_or_panic(v[47] == 21);
	5566	assert_or_panic(v[48] == 22);
	5567	assert_or_panic(v[49] == 23);
	5568	assert_or_panic(v[50] == 24);
	5569	assert_or_panic(v[51] == 25);
	5570	assert_or_panic(v[52] == 26);
	5571	assert_or_panic(v[53] == 27);
	5572	assert_or_panic(v[54] == 28);
	5573	assert_or_panic(v[55] == 29);
	5574	assert_or_panic(v[56] == 30);
	5575	assert_or_panic(v[57] == 31);
	5576	assert_or_panic(v[58] == 32);
	5577	assert_or_panic(v[59] == 33);
	5578	assert_or_panic(v[60] == 34);
	5579	assert_or_panic(v[61] == 35);
	5580	assert_or_panic(v[62] == 36);
	5581	assert_or_panic(v[63] == 37);
	5582	assert_or_panic(v[64] == 38);
	5583	assert_or_panic(v[65] == 39);
	5584	assert_or_panic(v[66] == 40);
	5585	assert_or_panic(v[67] == 41);
	5586	assert_or_panic(v[68] == 42);
	5587	assert_or_panic(v[69] == 43);
	5588	assert_or_panic(v[70] == 44);
	5589	assert_or_panic(v[71] == 45);
	5590	assert_or_panic(v[72] == 46);
	5591	assert_or_panic(v[73] == 47);
	5592	assert_or_panic(v[74] == 48);
	5593	assert_or_panic(v[75] == 49);
	5594	assert_or_panic(v[76] == 50);
	5595	assert_or_panic(v[77] == 51);
	5596	assert_or_panic(v[78] == 52);
	5597	assert_or_panic(v[79] == 53);
	5598	assert_or_panic(v[80] == 54);
	5599	assert_or_panic(v[81] == 55);
	5600	assert_or_panic(v[82] == 56);
	5601	assert_or_panic(v[83] == 57);
	5602	assert_or_panic(v[84] == 58);
	5603	assert_or_panic(v[85] == 59);
	5604	assert_or_panic(v[86] == 60);
	5605	assert_or_panic(v[87] == 61);
	5606	assert_or_panic(v[88] == 62);
	5607	assert_or_panic(v[89] == 63);
	5608	assert_or_panic(v[90] == 64);
	5609	assert_or_panic(v[91] == 65);
	5610	assert_or_panic(v[92] == 66);
	5611	assert_or_panic(v[93] == 67);
	5612	assert_or_panic(v[94] == 68);
	5613	assert_or_panic(v[95] == 69);
	5614	assert_or_panic(v[96] == 70);
	5615	assert_or_panic(v[97] == 71);
	5616	assert_or_panic(v[98] == 72);
	5617	assert_or_panic(v[99] == 73);
	5618	assert_or_panic(v[100] == 74);
	5619	assert_or_panic(v[101] == 75);
	5620	assert_or_panic(v[102] == 76);
	5621	assert_or_panic(v[103] == 77);
	5622	assert_or_panic(v[104] == 78);
	5623	assert_or_panic(v[105] == 79);
	5624	assert_or_panic(v[106] == 80);
	5625	assert_or_panic(v[107] == 81);
	5626	assert_or_panic(v[108] == 82);
	5627	assert_or_panic(v[109] == 83);
	5628	assert_or_panic(v[110] == 84);
	5629	assert_or_panic(v[111] == 85);
	5630	assert_or_panic(v[112] == 86);
	5631	assert_or_panic(v[113] == 87);
	5632	assert_or_panic(v[114] == 88);
	5633	assert_or_panic(v[115] == 89);
	5634	assert_or_panic(v[116] == 90);
	5635	assert_or_panic(v[117] == 91);
	5636	assert_or_panic(v[118] == 92);
	5637	assert_or_panic(v[119] == 93);
	5638	assert_or_panic(v[120] == 94);
	5639	assert_or_panic(v[121] == 95);
	5640	assert_or_panic(v[122] == 96);
	5641	assert_or_panic(v[123] == 97);
	5642	assert_or_panic(v[124] == 98);
	5643	assert_or_panic(v[125] == 99);
	5644	assert_or_panic(v[126] == 0);
	5645	assert_or_panic(v[127] == 1);
	5646	zig_vector_128_u8((Vector_128_u8){
	5647	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	5648	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	5649	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	5650	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	5651	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	5652	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	5653	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	5654	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	5655	}, 128);
	5656	}
	5657
	5658	typedef uint8_t Vector_192_u8 __attribute__((vector_size(192 * sizeof(uint8_t))));
	5659
	5660	Vector_192_u8 zig_ret_vector_192_u8(void);
	5661	void zig_vector_192_u8(Vector_192_u8, size_t);
	5662
	5663	Vector_192_u8 c_ret_vector_192_u8(void) {
	5664	return (Vector_192_u8){
	5665	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	5666	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	5667	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	5668	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	5669	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	5670	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	5671	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	5672	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	5673	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	5674	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	5675	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	5676	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	5677	};
	5678	}
	5679	void c_vector_192_u8(Vector_192_u8 v, size_t i) {
	5680	assert_or_panic(v[0] == 62);
	5681	assert_or_panic(v[1] == 63);
	5682	assert_or_panic(v[2] == 64);
	5683	assert_or_panic(v[3] == 65);
	5684	assert_or_panic(v[4] == 66);
	5685	assert_or_panic(v[5] == 67);
	5686	assert_or_panic(v[6] == 68);
	5687	assert_or_panic(v[7] == 69);
	5688	assert_or_panic(v[8] == 70);
	5689	assert_or_panic(v[9] == 71);
	5690	assert_or_panic(v[10] == 72);
	5691	assert_or_panic(v[11] == 73);
	5692	assert_or_panic(v[12] == 74);
	5693	assert_or_panic(v[13] == 75);
	5694	assert_or_panic(v[14] == 76);
	5695	assert_or_panic(v[15] == 77);
	5696	assert_or_panic(v[16] == 78);
	5697	assert_or_panic(v[17] == 79);
	5698	assert_or_panic(v[18] == 80);
	5699	assert_or_panic(v[19] == 81);
	5700	assert_or_panic(v[20] == 82);
	5701	assert_or_panic(v[21] == 83);
	5702	assert_or_panic(v[22] == 84);
	5703	assert_or_panic(v[23] == 85);
	5704	assert_or_panic(v[24] == 86);
	5705	assert_or_panic(v[25] == 87);
	5706	assert_or_panic(v[26] == 88);
	5707	assert_or_panic(v[27] == 89);
	5708	assert_or_panic(v[28] == 90);
	5709	assert_or_panic(v[29] == 91);
	5710	assert_or_panic(v[30] == 92);
	5711	assert_or_panic(v[31] == 93);
	5712	assert_or_panic(v[32] == 94);
	5713	assert_or_panic(v[33] == 95);
	5714	assert_or_panic(v[34] == 96);
	5715	assert_or_panic(v[35] == 97);
	5716	assert_or_panic(v[36] == 98);
	5717	assert_or_panic(v[37] == 99);
	5718	assert_or_panic(v[38] == 0);
	5719	assert_or_panic(v[39] == 1);
	5720	assert_or_panic(v[40] == 2);
	5721	assert_or_panic(v[41] == 3);
	5722	assert_or_panic(v[42] == 4);
	5723	assert_or_panic(v[43] == 5);
	5724	assert_or_panic(v[44] == 6);
	5725	assert_or_panic(v[45] == 7);
	5726	assert_or_panic(v[46] == 8);
	5727	assert_or_panic(v[47] == 9);
	5728	assert_or_panic(v[48] == 10);
	5729	assert_or_panic(v[49] == 11);
	5730	assert_or_panic(v[50] == 12);
	5731	assert_or_panic(v[51] == 13);
	5732	assert_or_panic(v[52] == 14);
	5733	assert_or_panic(v[53] == 15);
	5734	assert_or_panic(v[54] == 16);
	5735	assert_or_panic(v[55] == 17);
	5736	assert_or_panic(v[56] == 18);
	5737	assert_or_panic(v[57] == 19);
	5738	assert_or_panic(v[58] == 20);
	5739	assert_or_panic(v[59] == 21);
	5740	assert_or_panic(v[60] == 22);
	5741	assert_or_panic(v[61] == 23);
	5742	assert_or_panic(v[62] == 24);
	5743	assert_or_panic(v[63] == 25);
	5744	assert_or_panic(v[64] == 26);
	5745	assert_or_panic(v[65] == 27);
	5746	assert_or_panic(v[66] == 28);
	5747	assert_or_panic(v[67] == 29);
	5748	assert_or_panic(v[68] == 30);
	5749	assert_or_panic(v[69] == 31);
	5750	assert_or_panic(v[70] == 32);
	5751	assert_or_panic(v[71] == 33);
	5752	assert_or_panic(v[72] == 34);
	5753	assert_or_panic(v[73] == 35);
	5754	assert_or_panic(v[74] == 36);
	5755	assert_or_panic(v[75] == 37);
	5756	assert_or_panic(v[76] == 38);
	5757	assert_or_panic(v[77] == 39);
	5758	assert_or_panic(v[78] == 40);
	5759	assert_or_panic(v[79] == 41);
	5760	assert_or_panic(v[80] == 42);
	5761	assert_or_panic(v[81] == 43);
	5762	assert_or_panic(v[82] == 44);
	5763	assert_or_panic(v[83] == 45);
	5764	assert_or_panic(v[84] == 46);
	5765	assert_or_panic(v[85] == 47);
	5766	assert_or_panic(v[86] == 48);
	5767	assert_or_panic(v[87] == 49);
	5768	assert_or_panic(v[88] == 50);
	5769	assert_or_panic(v[89] == 51);
	5770	assert_or_panic(v[90] == 52);
	5771	assert_or_panic(v[91] == 53);
	5772	assert_or_panic(v[92] == 54);
	5773	assert_or_panic(v[93] == 55);
	5774	assert_or_panic(v[94] == 56);
	5775	assert_or_panic(v[95] == 57);
	5776	assert_or_panic(v[96] == 58);
	5777	assert_or_panic(v[97] == 59);
	5778	assert_or_panic(v[98] == 60);
	5779	assert_or_panic(v[99] == 61);
	5780	assert_or_panic(v[100] == 62);
	5781	assert_or_panic(v[101] == 63);
	5782	assert_or_panic(v[102] == 64);
	5783	assert_or_panic(v[103] == 65);
	5784	assert_or_panic(v[104] == 66);
	5785	assert_or_panic(v[105] == 67);
	5786	assert_or_panic(v[106] == 68);
	5787	assert_or_panic(v[107] == 69);
	5788	assert_or_panic(v[108] == 70);
	5789	assert_or_panic(v[109] == 71);
	5790	assert_or_panic(v[110] == 72);
	5791	assert_or_panic(v[111] == 73);
	5792	assert_or_panic(v[112] == 74);
	5793	assert_or_panic(v[113] == 75);
	5794	assert_or_panic(v[114] == 76);
	5795	assert_or_panic(v[115] == 77);
	5796	assert_or_panic(v[116] == 78);
	5797	assert_or_panic(v[117] == 79);
	5798	assert_or_panic(v[118] == 80);
	5799	assert_or_panic(v[119] == 81);
	5800	assert_or_panic(v[120] == 82);
	5801	assert_or_panic(v[121] == 83);
	5802	assert_or_panic(v[122] == 84);
	5803	assert_or_panic(v[123] == 85);
	5804	assert_or_panic(v[124] == 86);
	5805	assert_or_panic(v[125] == 87);
	5806	assert_or_panic(v[126] == 88);
	5807	assert_or_panic(v[127] == 89);
	5808	assert_or_panic(v[128] == 90);
	5809	assert_or_panic(v[129] == 91);
	5810	assert_or_panic(v[130] == 92);
	5811	assert_or_panic(v[131] == 93);
	5812	assert_or_panic(v[132] == 94);
	5813	assert_or_panic(v[133] == 95);
	5814	assert_or_panic(v[134] == 96);
	5815	assert_or_panic(v[135] == 97);
	5816	assert_or_panic(v[136] == 98);
	5817	assert_or_panic(v[137] == 99);
	5818	assert_or_panic(v[138] == 0);
	5819	assert_or_panic(v[139] == 1);
	5820	assert_or_panic(v[140] == 2);
	5821	assert_or_panic(v[141] == 3);
	5822	assert_or_panic(v[142] == 4);
	5823	assert_or_panic(v[143] == 5);
	5824	assert_or_panic(v[144] == 6);
	5825	assert_or_panic(v[145] == 7);
	5826	assert_or_panic(v[146] == 8);
	5827	assert_or_panic(v[147] == 9);
	5828	assert_or_panic(v[148] == 10);
	5829	assert_or_panic(v[149] == 11);
	5830	assert_or_panic(v[150] == 12);
	5831	assert_or_panic(v[151] == 13);
	5832	assert_or_panic(v[152] == 14);
	5833	assert_or_panic(v[153] == 15);
	5834	assert_or_panic(v[154] == 16);
	5835	assert_or_panic(v[155] == 17);
	5836	assert_or_panic(v[156] == 18);
	5837	assert_or_panic(v[157] == 19);
	5838	assert_or_panic(v[158] == 20);
	5839	assert_or_panic(v[159] == 21);
	5840	assert_or_panic(v[160] == 22);
	5841	assert_or_panic(v[161] == 23);
	5842	assert_or_panic(v[162] == 24);
	5843	assert_or_panic(v[163] == 25);
	5844	assert_or_panic(v[164] == 26);
	5845	assert_or_panic(v[165] == 27);
	5846	assert_or_panic(v[166] == 28);
	5847	assert_or_panic(v[167] == 29);
	5848	assert_or_panic(v[168] == 30);
	5849	assert_or_panic(v[169] == 31);
	5850	assert_or_panic(v[170] == 32);
	5851	assert_or_panic(v[171] == 33);
	5852	assert_or_panic(v[172] == 34);
	5853	assert_or_panic(v[173] == 35);
	5854	assert_or_panic(v[174] == 36);
	5855	assert_or_panic(v[175] == 37);
	5856	assert_or_panic(v[176] == 38);
	5857	assert_or_panic(v[177] == 39);
	5858	assert_or_panic(v[178] == 40);
	5859	assert_or_panic(v[179] == 41);
	5860	assert_or_panic(v[180] == 42);
	5861	assert_or_panic(v[181] == 43);
	5862	assert_or_panic(v[182] == 44);
	5863	assert_or_panic(v[183] == 45);
	5864	assert_or_panic(v[184] == 46);
	5865	assert_or_panic(v[185] == 47);
	5866	assert_or_panic(v[186] == 48);
	5867	assert_or_panic(v[187] == 49);
	5868	assert_or_panic(v[188] == 50);
	5869	assert_or_panic(v[189] == 51);
	5870	assert_or_panic(v[190] == 52);
	5871	assert_or_panic(v[191] == 53);
	5872	assert_or_panic(i == 192);
	5873	}
	5874	void c_test_vector_192_u8(void) {
	5875	Vector_192_u8 v = zig_ret_vector_192_u8();
	5876	assert_or_panic(v[0] == 86);
	5877	assert_or_panic(v[1] == 87);
	5878	assert_or_panic(v[2] == 88);
	5879	assert_or_panic(v[3] == 89);
	5880	assert_or_panic(v[4] == 90);
	5881	assert_or_panic(v[5] == 91);
	5882	assert_or_panic(v[6] == 92);
	5883	assert_or_panic(v[7] == 93);
	5884	assert_or_panic(v[8] == 94);
	5885	assert_or_panic(v[9] == 95);
	5886	assert_or_panic(v[10] == 96);
	5887	assert_or_panic(v[11] == 97);
	5888	assert_or_panic(v[12] == 98);
	5889	assert_or_panic(v[13] == 99);
	5890	assert_or_panic(v[14] == 0);
	5891	assert_or_panic(v[15] == 1);
	5892	assert_or_panic(v[16] == 2);
	5893	assert_or_panic(v[17] == 3);
	5894	assert_or_panic(v[18] == 4);
	5895	assert_or_panic(v[19] == 5);
	5896	assert_or_panic(v[20] == 6);
	5897	assert_or_panic(v[21] == 7);
	5898	assert_or_panic(v[22] == 8);
	5899	assert_or_panic(v[23] == 9);
	5900	assert_or_panic(v[24] == 10);
	5901	assert_or_panic(v[25] == 11);
	5902	assert_or_panic(v[26] == 12);
	5903	assert_or_panic(v[27] == 13);
	5904	assert_or_panic(v[28] == 14);
	5905	assert_or_panic(v[29] == 15);
	5906	assert_or_panic(v[30] == 16);
	5907	assert_or_panic(v[31] == 17);
	5908	assert_or_panic(v[32] == 18);
	5909	assert_or_panic(v[33] == 19);
	5910	assert_or_panic(v[34] == 20);
	5911	assert_or_panic(v[35] == 21);
	5912	assert_or_panic(v[36] == 22);
	5913	assert_or_panic(v[37] == 23);
	5914	assert_or_panic(v[38] == 24);
	5915	assert_or_panic(v[39] == 25);
	5916	assert_or_panic(v[40] == 26);
	5917	assert_or_panic(v[41] == 27);
	5918	assert_or_panic(v[42] == 28);
	5919	assert_or_panic(v[43] == 29);
	5920	assert_or_panic(v[44] == 30);
	5921	assert_or_panic(v[45] == 31);
	5922	assert_or_panic(v[46] == 32);
	5923	assert_or_panic(v[47] == 33);
	5924	assert_or_panic(v[48] == 34);
	5925	assert_or_panic(v[49] == 35);
	5926	assert_or_panic(v[50] == 36);
	5927	assert_or_panic(v[51] == 37);
	5928	assert_or_panic(v[52] == 38);
	5929	assert_or_panic(v[53] == 39);
	5930	assert_or_panic(v[54] == 40);
	5931	assert_or_panic(v[55] == 41);
	5932	assert_or_panic(v[56] == 42);
	5933	assert_or_panic(v[57] == 43);
	5934	assert_or_panic(v[58] == 44);
	5935	assert_or_panic(v[59] == 45);
	5936	assert_or_panic(v[60] == 46);
	5937	assert_or_panic(v[61] == 47);
	5938	assert_or_panic(v[62] == 48);
	5939	assert_or_panic(v[63] == 49);
	5940	assert_or_panic(v[64] == 50);
	5941	assert_or_panic(v[65] == 51);
	5942	assert_or_panic(v[66] == 52);
	5943	assert_or_panic(v[67] == 53);
	5944	assert_or_panic(v[68] == 54);
	5945	assert_or_panic(v[69] == 55);
	5946	assert_or_panic(v[70] == 56);
	5947	assert_or_panic(v[71] == 57);
	5948	assert_or_panic(v[72] == 58);
	5949	assert_or_panic(v[73] == 59);
	5950	assert_or_panic(v[74] == 60);
	5951	assert_or_panic(v[75] == 61);
	5952	assert_or_panic(v[76] == 62);
	5953	assert_or_panic(v[77] == 63);
	5954	assert_or_panic(v[78] == 64);
	5955	assert_or_panic(v[79] == 65);
	5956	assert_or_panic(v[80] == 66);
	5957	assert_or_panic(v[81] == 67);
	5958	assert_or_panic(v[82] == 68);
	5959	assert_or_panic(v[83] == 69);
	5960	assert_or_panic(v[84] == 70);
	5961	assert_or_panic(v[85] == 71);
	5962	assert_or_panic(v[86] == 72);
	5963	assert_or_panic(v[87] == 73);
	5964	assert_or_panic(v[88] == 74);
	5965	assert_or_panic(v[89] == 75);
	5966	assert_or_panic(v[90] == 76);
	5967	assert_or_panic(v[91] == 77);
	5968	assert_or_panic(v[92] == 78);
	5969	assert_or_panic(v[93] == 79);
	5970	assert_or_panic(v[94] == 80);
	5971	assert_or_panic(v[95] == 81);
	5972	assert_or_panic(v[96] == 82);
	5973	assert_or_panic(v[97] == 83);
	5974	assert_or_panic(v[98] == 84);
	5975	assert_or_panic(v[99] == 85);
	5976	assert_or_panic(v[100] == 86);
	5977	assert_or_panic(v[101] == 87);
	5978	assert_or_panic(v[102] == 88);
	5979	assert_or_panic(v[103] == 89);
	5980	assert_or_panic(v[104] == 90);
	5981	assert_or_panic(v[105] == 91);
	5982	assert_or_panic(v[106] == 92);
	5983	assert_or_panic(v[107] == 93);
	5984	assert_or_panic(v[108] == 94);
	5985	assert_or_panic(v[109] == 95);
	5986	assert_or_panic(v[110] == 96);
	5987	assert_or_panic(v[111] == 97);
	5988	assert_or_panic(v[112] == 98);
	5989	assert_or_panic(v[113] == 99);
	5990	assert_or_panic(v[114] == 0);
	5991	assert_or_panic(v[115] == 1);
	5992	assert_or_panic(v[116] == 2);
	5993	assert_or_panic(v[117] == 3);
	5994	assert_or_panic(v[118] == 4);
	5995	assert_or_panic(v[119] == 5);
	5996	assert_or_panic(v[120] == 6);
	5997	assert_or_panic(v[121] == 7);
	5998	assert_or_panic(v[122] == 8);
	5999	assert_or_panic(v[123] == 9);
	6000	assert_or_panic(v[124] == 10);
	6001	assert_or_panic(v[125] == 11);
	6002	assert_or_panic(v[126] == 12);
	6003	assert_or_panic(v[127] == 13);
	6004	assert_or_panic(v[128] == 14);
	6005	assert_or_panic(v[129] == 15);
	6006	assert_or_panic(v[130] == 16);
	6007	assert_or_panic(v[131] == 17);
	6008	assert_or_panic(v[132] == 18);
	6009	assert_or_panic(v[133] == 19);
	6010	assert_or_panic(v[134] == 20);
	6011	assert_or_panic(v[135] == 21);
	6012	assert_or_panic(v[136] == 22);
	6013	assert_or_panic(v[137] == 23);
	6014	assert_or_panic(v[138] == 24);
	6015	assert_or_panic(v[139] == 25);
	6016	assert_or_panic(v[140] == 26);
	6017	assert_or_panic(v[141] == 27);
	6018	assert_or_panic(v[142] == 28);
	6019	assert_or_panic(v[143] == 29);
	6020	assert_or_panic(v[144] == 30);
	6021	assert_or_panic(v[145] == 31);
	6022	assert_or_panic(v[146] == 32);
	6023	assert_or_panic(v[147] == 33);
	6024	assert_or_panic(v[148] == 34);
	6025	assert_or_panic(v[149] == 35);
	6026	assert_or_panic(v[150] == 36);
	6027	assert_or_panic(v[151] == 37);
	6028	assert_or_panic(v[152] == 38);
	6029	assert_or_panic(v[153] == 39);
	6030	assert_or_panic(v[154] == 40);
	6031	assert_or_panic(v[155] == 41);
	6032	assert_or_panic(v[156] == 42);
	6033	assert_or_panic(v[157] == 43);
	6034	assert_or_panic(v[158] == 44);
	6035	assert_or_panic(v[159] == 45);
	6036	assert_or_panic(v[160] == 46);
	6037	assert_or_panic(v[161] == 47);
	6038	assert_or_panic(v[162] == 48);
	6039	assert_or_panic(v[163] == 49);
	6040	assert_or_panic(v[164] == 50);
	6041	assert_or_panic(v[165] == 51);
	6042	assert_or_panic(v[166] == 52);
	6043	assert_or_panic(v[167] == 53);
	6044	assert_or_panic(v[168] == 54);
	6045	assert_or_panic(v[169] == 55);
	6046	assert_or_panic(v[170] == 56);
	6047	assert_or_panic(v[171] == 57);
	6048	assert_or_panic(v[172] == 58);
	6049	assert_or_panic(v[173] == 59);
	6050	assert_or_panic(v[174] == 60);
	6051	assert_or_panic(v[175] == 61);
	6052	assert_or_panic(v[176] == 62);
	6053	assert_or_panic(v[177] == 63);
	6054	assert_or_panic(v[178] == 64);
	6055	assert_or_panic(v[179] == 65);
	6056	assert_or_panic(v[180] == 66);
	6057	assert_or_panic(v[181] == 67);
	6058	assert_or_panic(v[182] == 68);
	6059	assert_or_panic(v[183] == 69);
	6060	assert_or_panic(v[184] == 70);
	6061	assert_or_panic(v[185] == 71);
	6062	assert_or_panic(v[186] == 72);
	6063	assert_or_panic(v[187] == 73);
	6064	assert_or_panic(v[188] == 74);
	6065	assert_or_panic(v[189] == 75);
	6066	assert_or_panic(v[190] == 76);
	6067	assert_or_panic(v[191] == 77);
	6068	zig_vector_192_u8((Vector_192_u8){
	6069	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	6070	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	6071	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	6072	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	6073	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	6074	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	6075	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	6076	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	6077	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	6078	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	6079	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	6080	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	6081	}, 192);
	6082	}
	6083
	6084	typedef uint8_t Vector_256_u8 __attribute__((vector_size(256 * sizeof(uint8_t))));
	6085
	6086	Vector_256_u8 zig_ret_vector_256_u8(void);
	6087	void zig_vector_256_u8(Vector_256_u8, size_t);
	6088
	6089	Vector_256_u8 c_ret_vector_256_u8(void) {
	6090	return (Vector_256_u8){
	6091	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	6092	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	6093	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	6094	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	6095	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	6096	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	6097	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	6098	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	6099	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	6100	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	6101	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	6102	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	6103	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	6104	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	6105	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	6106	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	6107	};
	6108	}
	6109	void c_vector_256_u8(Vector_256_u8 v, size_t i) {
	6110	assert_or_panic(v[0] == 22);
	6111	assert_or_panic(v[1] == 23);
	6112	assert_or_panic(v[2] == 24);
	6113	assert_or_panic(v[3] == 25);
	6114	assert_or_panic(v[4] == 26);
	6115	assert_or_panic(v[5] == 27);
	6116	assert_or_panic(v[6] == 28);
	6117	assert_or_panic(v[7] == 29);
	6118	assert_or_panic(v[8] == 30);
	6119	assert_or_panic(v[9] == 31);
	6120	assert_or_panic(v[10] == 32);
	6121	assert_or_panic(v[11] == 33);
	6122	assert_or_panic(v[12] == 34);
	6123	assert_or_panic(v[13] == 35);
	6124	assert_or_panic(v[14] == 36);
	6125	assert_or_panic(v[15] == 37);
	6126	assert_or_panic(v[16] == 38);
	6127	assert_or_panic(v[17] == 39);
	6128	assert_or_panic(v[18] == 40);
	6129	assert_or_panic(v[19] == 41);
	6130	assert_or_panic(v[20] == 42);
	6131	assert_or_panic(v[21] == 43);
	6132	assert_or_panic(v[22] == 44);
	6133	assert_or_panic(v[23] == 45);
	6134	assert_or_panic(v[24] == 46);
	6135	assert_or_panic(v[25] == 47);
	6136	assert_or_panic(v[26] == 48);
	6137	assert_or_panic(v[27] == 49);
	6138	assert_or_panic(v[28] == 50);
	6139	assert_or_panic(v[29] == 51);
	6140	assert_or_panic(v[30] == 52);
	6141	assert_or_panic(v[31] == 53);
	6142	assert_or_panic(v[32] == 54);
	6143	assert_or_panic(v[33] == 55);
	6144	assert_or_panic(v[34] == 56);
	6145	assert_or_panic(v[35] == 57);
	6146	assert_or_panic(v[36] == 58);
	6147	assert_or_panic(v[37] == 59);
	6148	assert_or_panic(v[38] == 60);
	6149	assert_or_panic(v[39] == 61);
	6150	assert_or_panic(v[40] == 62);
	6151	assert_or_panic(v[41] == 63);
	6152	assert_or_panic(v[42] == 64);
	6153	assert_or_panic(v[43] == 65);
	6154	assert_or_panic(v[44] == 66);
	6155	assert_or_panic(v[45] == 67);
	6156	assert_or_panic(v[46] == 68);
	6157	assert_or_panic(v[47] == 69);
	6158	assert_or_panic(v[48] == 70);
	6159	assert_or_panic(v[49] == 71);
	6160	assert_or_panic(v[50] == 72);
	6161	assert_or_panic(v[51] == 73);
	6162	assert_or_panic(v[52] == 74);
	6163	assert_or_panic(v[53] == 75);
	6164	assert_or_panic(v[54] == 76);
	6165	assert_or_panic(v[55] == 77);
	6166	assert_or_panic(v[56] == 78);
	6167	assert_or_panic(v[57] == 79);
	6168	assert_or_panic(v[58] == 80);
	6169	assert_or_panic(v[59] == 81);
	6170	assert_or_panic(v[60] == 82);
	6171	assert_or_panic(v[61] == 83);
	6172	assert_or_panic(v[62] == 84);
	6173	assert_or_panic(v[63] == 85);
	6174	assert_or_panic(v[64] == 86);
	6175	assert_or_panic(v[65] == 87);
	6176	assert_or_panic(v[66] == 88);
	6177	assert_or_panic(v[67] == 89);
	6178	assert_or_panic(v[68] == 90);
	6179	assert_or_panic(v[69] == 91);
	6180	assert_or_panic(v[70] == 92);
	6181	assert_or_panic(v[71] == 93);
	6182	assert_or_panic(v[72] == 94);
	6183	assert_or_panic(v[73] == 95);
	6184	assert_or_panic(v[74] == 96);
	6185	assert_or_panic(v[75] == 97);
	6186	assert_or_panic(v[76] == 98);
	6187	assert_or_panic(v[77] == 99);
	6188	assert_or_panic(v[78] == 0);
	6189	assert_or_panic(v[79] == 1);
	6190	assert_or_panic(v[80] == 2);
	6191	assert_or_panic(v[81] == 3);
	6192	assert_or_panic(v[82] == 4);
	6193	assert_or_panic(v[83] == 5);
	6194	assert_or_panic(v[84] == 6);
	6195	assert_or_panic(v[85] == 7);
	6196	assert_or_panic(v[86] == 8);
	6197	assert_or_panic(v[87] == 9);
	6198	assert_or_panic(v[88] == 10);
	6199	assert_or_panic(v[89] == 11);
	6200	assert_or_panic(v[90] == 12);
	6201	assert_or_panic(v[91] == 13);
	6202	assert_or_panic(v[92] == 14);
	6203	assert_or_panic(v[93] == 15);
	6204	assert_or_panic(v[94] == 16);
	6205	assert_or_panic(v[95] == 17);
	6206	assert_or_panic(v[96] == 18);
	6207	assert_or_panic(v[97] == 19);
	6208	assert_or_panic(v[98] == 20);
	6209	assert_or_panic(v[99] == 21);
	6210	assert_or_panic(v[100] == 22);
	6211	assert_or_panic(v[101] == 23);
	6212	assert_or_panic(v[102] == 24);
	6213	assert_or_panic(v[103] == 25);
	6214	assert_or_panic(v[104] == 26);
	6215	assert_or_panic(v[105] == 27);
	6216	assert_or_panic(v[106] == 28);
	6217	assert_or_panic(v[107] == 29);
	6218	assert_or_panic(v[108] == 30);
	6219	assert_or_panic(v[109] == 31);
	6220	assert_or_panic(v[110] == 32);
	6221	assert_or_panic(v[111] == 33);
	6222	assert_or_panic(v[112] == 34);
	6223	assert_or_panic(v[113] == 35);
	6224	assert_or_panic(v[114] == 36);
	6225	assert_or_panic(v[115] == 37);
	6226	assert_or_panic(v[116] == 38);
	6227	assert_or_panic(v[117] == 39);
	6228	assert_or_panic(v[118] == 40);
	6229	assert_or_panic(v[119] == 41);
	6230	assert_or_panic(v[120] == 42);
	6231	assert_or_panic(v[121] == 43);
	6232	assert_or_panic(v[122] == 44);
	6233	assert_or_panic(v[123] == 45);
	6234	assert_or_panic(v[124] == 46);
	6235	assert_or_panic(v[125] == 47);
	6236	assert_or_panic(v[126] == 48);
	6237	assert_or_panic(v[127] == 49);
	6238	assert_or_panic(v[128] == 50);
	6239	assert_or_panic(v[129] == 51);
	6240	assert_or_panic(v[130] == 52);
	6241	assert_or_panic(v[131] == 53);
	6242	assert_or_panic(v[132] == 54);
	6243	assert_or_panic(v[133] == 55);
	6244	assert_or_panic(v[134] == 56);
	6245	assert_or_panic(v[135] == 57);
	6246	assert_or_panic(v[136] == 58);
	6247	assert_or_panic(v[137] == 59);
	6248	assert_or_panic(v[138] == 60);
	6249	assert_or_panic(v[139] == 61);
	6250	assert_or_panic(v[140] == 62);
	6251	assert_or_panic(v[141] == 63);
	6252	assert_or_panic(v[142] == 64);
	6253	assert_or_panic(v[143] == 65);
	6254	assert_or_panic(v[144] == 66);
	6255	assert_or_panic(v[145] == 67);
	6256	assert_or_panic(v[146] == 68);
	6257	assert_or_panic(v[147] == 69);
	6258	assert_or_panic(v[148] == 70);
	6259	assert_or_panic(v[149] == 71);
	6260	assert_or_panic(v[150] == 72);
	6261	assert_or_panic(v[151] == 73);
	6262	assert_or_panic(v[152] == 74);
	6263	assert_or_panic(v[153] == 75);
	6264	assert_or_panic(v[154] == 76);
	6265	assert_or_panic(v[155] == 77);
	6266	assert_or_panic(v[156] == 78);
	6267	assert_or_panic(v[157] == 79);
	6268	assert_or_panic(v[158] == 80);
	6269	assert_or_panic(v[159] == 81);
	6270	assert_or_panic(v[160] == 82);
	6271	assert_or_panic(v[161] == 83);
	6272	assert_or_panic(v[162] == 84);
	6273	assert_or_panic(v[163] == 85);
	6274	assert_or_panic(v[164] == 86);
	6275	assert_or_panic(v[165] == 87);
	6276	assert_or_panic(v[166] == 88);
	6277	assert_or_panic(v[167] == 89);
	6278	assert_or_panic(v[168] == 90);
	6279	assert_or_panic(v[169] == 91);
	6280	assert_or_panic(v[170] == 92);
	6281	assert_or_panic(v[171] == 93);
	6282	assert_or_panic(v[172] == 94);
	6283	assert_or_panic(v[173] == 95);
	6284	assert_or_panic(v[174] == 96);
	6285	assert_or_panic(v[175] == 97);
	6286	assert_or_panic(v[176] == 98);
	6287	assert_or_panic(v[177] == 99);
	6288	assert_or_panic(v[178] == 0);
	6289	assert_or_panic(v[179] == 1);
	6290	assert_or_panic(v[180] == 2);
	6291	assert_or_panic(v[181] == 3);
	6292	assert_or_panic(v[182] == 4);
	6293	assert_or_panic(v[183] == 5);
	6294	assert_or_panic(v[184] == 6);
	6295	assert_or_panic(v[185] == 7);
	6296	assert_or_panic(v[186] == 8);
	6297	assert_or_panic(v[187] == 9);
	6298	assert_or_panic(v[188] == 10);
	6299	assert_or_panic(v[189] == 11);
	6300	assert_or_panic(v[190] == 12);
	6301	assert_or_panic(v[191] == 13);
	6302	assert_or_panic(v[192] == 14);
	6303	assert_or_panic(v[193] == 15);
	6304	assert_or_panic(v[194] == 16);
	6305	assert_or_panic(v[195] == 17);
	6306	assert_or_panic(v[196] == 18);
	6307	assert_or_panic(v[197] == 19);
	6308	assert_or_panic(v[198] == 20);
	6309	assert_or_panic(v[199] == 21);
	6310	assert_or_panic(v[200] == 22);
	6311	assert_or_panic(v[201] == 23);
	6312	assert_or_panic(v[202] == 24);
	6313	assert_or_panic(v[203] == 25);
	6314	assert_or_panic(v[204] == 26);
	6315	assert_or_panic(v[205] == 27);
	6316	assert_or_panic(v[206] == 28);
	6317	assert_or_panic(v[207] == 29);
	6318	assert_or_panic(v[208] == 30);
	6319	assert_or_panic(v[209] == 31);
	6320	assert_or_panic(v[210] == 32);
	6321	assert_or_panic(v[211] == 33);
	6322	assert_or_panic(v[212] == 34);
	6323	assert_or_panic(v[213] == 35);
	6324	assert_or_panic(v[214] == 36);
	6325	assert_or_panic(v[215] == 37);
	6326	assert_or_panic(v[216] == 38);
	6327	assert_or_panic(v[217] == 39);
	6328	assert_or_panic(v[218] == 40);
	6329	assert_or_panic(v[219] == 41);
	6330	assert_or_panic(v[220] == 42);
	6331	assert_or_panic(v[221] == 43);
	6332	assert_or_panic(v[222] == 44);
	6333	assert_or_panic(v[223] == 45);
	6334	assert_or_panic(v[224] == 46);
	6335	assert_or_panic(v[225] == 47);
	6336	assert_or_panic(v[226] == 48);
	6337	assert_or_panic(v[227] == 49);
	6338	assert_or_panic(v[228] == 50);
	6339	assert_or_panic(v[229] == 51);
	6340	assert_or_panic(v[230] == 52);
	6341	assert_or_panic(v[231] == 53);
	6342	assert_or_panic(v[232] == 54);
	6343	assert_or_panic(v[233] == 55);
	6344	assert_or_panic(v[234] == 56);
	6345	assert_or_panic(v[235] == 57);
	6346	assert_or_panic(v[236] == 58);
	6347	assert_or_panic(v[237] == 59);
	6348	assert_or_panic(v[238] == 60);
	6349	assert_or_panic(v[239] == 61);
	6350	assert_or_panic(v[240] == 62);
	6351	assert_or_panic(v[241] == 63);
	6352	assert_or_panic(v[242] == 64);
	6353	assert_or_panic(v[243] == 65);
	6354	assert_or_panic(v[244] == 66);
	6355	assert_or_panic(v[245] == 67);
	6356	assert_or_panic(v[246] == 68);
	6357	assert_or_panic(v[247] == 69);
	6358	assert_or_panic(v[248] == 70);
	6359	assert_or_panic(v[249] == 71);
	6360	assert_or_panic(v[250] == 72);
	6361	assert_or_panic(v[251] == 73);
	6362	assert_or_panic(v[252] == 74);
	6363	assert_or_panic(v[253] == 75);
	6364	assert_or_panic(v[254] == 76);
	6365	assert_or_panic(v[255] == 77);
	6366	assert_or_panic(i == 256);
	6367	}
	6368	void c_test_vector_256_u8(void) {
	6369	Vector_256_u8 v = zig_ret_vector_256_u8();
	6370	assert_or_panic(v[0] == 54);
	6371	assert_or_panic(v[1] == 55);
	6372	assert_or_panic(v[2] == 56);
	6373	assert_or_panic(v[3] == 57);
	6374	assert_or_panic(v[4] == 58);
	6375	assert_or_panic(v[5] == 59);
	6376	assert_or_panic(v[6] == 60);
	6377	assert_or_panic(v[7] == 61);
	6378	assert_or_panic(v[8] == 62);
	6379	assert_or_panic(v[9] == 63);
	6380	assert_or_panic(v[10] == 64);
	6381	assert_or_panic(v[11] == 65);
	6382	assert_or_panic(v[12] == 66);
	6383	assert_or_panic(v[13] == 67);
	6384	assert_or_panic(v[14] == 68);
	6385	assert_or_panic(v[15] == 69);
	6386	assert_or_panic(v[16] == 70);
	6387	assert_or_panic(v[17] == 71);
	6388	assert_or_panic(v[18] == 72);
	6389	assert_or_panic(v[19] == 73);
	6390	assert_or_panic(v[20] == 74);
	6391	assert_or_panic(v[21] == 75);
	6392	assert_or_panic(v[22] == 76);
	6393	assert_or_panic(v[23] == 77);
	6394	assert_or_panic(v[24] == 78);
	6395	assert_or_panic(v[25] == 79);
	6396	assert_or_panic(v[26] == 80);
	6397	assert_or_panic(v[27] == 81);
	6398	assert_or_panic(v[28] == 82);
	6399	assert_or_panic(v[29] == 83);
	6400	assert_or_panic(v[30] == 84);
	6401	assert_or_panic(v[31] == 85);
	6402	assert_or_panic(v[32] == 86);
	6403	assert_or_panic(v[33] == 87);
	6404	assert_or_panic(v[34] == 88);
	6405	assert_or_panic(v[35] == 89);
	6406	assert_or_panic(v[36] == 90);
	6407	assert_or_panic(v[37] == 91);
	6408	assert_or_panic(v[38] == 92);
	6409	assert_or_panic(v[39] == 93);
	6410	assert_or_panic(v[40] == 94);
	6411	assert_or_panic(v[41] == 95);
	6412	assert_or_panic(v[42] == 96);
	6413	assert_or_panic(v[43] == 97);
	6414	assert_or_panic(v[44] == 98);
	6415	assert_or_panic(v[45] == 99);
	6416	assert_or_panic(v[46] == 0);
	6417	assert_or_panic(v[47] == 1);
	6418	assert_or_panic(v[48] == 2);
	6419	assert_or_panic(v[49] == 3);
	6420	assert_or_panic(v[50] == 4);
	6421	assert_or_panic(v[51] == 5);
	6422	assert_or_panic(v[52] == 6);
	6423	assert_or_panic(v[53] == 7);
	6424	assert_or_panic(v[54] == 8);
	6425	assert_or_panic(v[55] == 9);
	6426	assert_or_panic(v[56] == 10);
	6427	assert_or_panic(v[57] == 11);
	6428	assert_or_panic(v[58] == 12);
	6429	assert_or_panic(v[59] == 13);
	6430	assert_or_panic(v[60] == 14);
	6431	assert_or_panic(v[61] == 15);
	6432	assert_or_panic(v[62] == 16);
	6433	assert_or_panic(v[63] == 17);
	6434	assert_or_panic(v[64] == 18);
	6435	assert_or_panic(v[65] == 19);
	6436	assert_or_panic(v[66] == 20);
	6437	assert_or_panic(v[67] == 21);
	6438	assert_or_panic(v[68] == 22);
	6439	assert_or_panic(v[69] == 23);
	6440	assert_or_panic(v[70] == 24);
	6441	assert_or_panic(v[71] == 25);
	6442	assert_or_panic(v[72] == 26);
	6443	assert_or_panic(v[73] == 27);
	6444	assert_or_panic(v[74] == 28);
	6445	assert_or_panic(v[75] == 29);
	6446	assert_or_panic(v[76] == 30);
	6447	assert_or_panic(v[77] == 31);
	6448	assert_or_panic(v[78] == 32);
	6449	assert_or_panic(v[79] == 33);
	6450	assert_or_panic(v[80] == 34);
	6451	assert_or_panic(v[81] == 35);
	6452	assert_or_panic(v[82] == 36);
	6453	assert_or_panic(v[83] == 37);
	6454	assert_or_panic(v[84] == 38);
	6455	assert_or_panic(v[85] == 39);
	6456	assert_or_panic(v[86] == 40);
	6457	assert_or_panic(v[87] == 41);
	6458	assert_or_panic(v[88] == 42);
	6459	assert_or_panic(v[89] == 43);
	6460	assert_or_panic(v[90] == 44);
	6461	assert_or_panic(v[91] == 45);
	6462	assert_or_panic(v[92] == 46);
	6463	assert_or_panic(v[93] == 47);
	6464	assert_or_panic(v[94] == 48);
	6465	assert_or_panic(v[95] == 49);
	6466	assert_or_panic(v[96] == 50);
	6467	assert_or_panic(v[97] == 51);
	6468	assert_or_panic(v[98] == 52);
	6469	assert_or_panic(v[99] == 53);
	6470	assert_or_panic(v[100] == 54);
	6471	assert_or_panic(v[101] == 55);
	6472	assert_or_panic(v[102] == 56);
	6473	assert_or_panic(v[103] == 57);
	6474	assert_or_panic(v[104] == 58);
	6475	assert_or_panic(v[105] == 59);
	6476	assert_or_panic(v[106] == 60);
	6477	assert_or_panic(v[107] == 61);
	6478	assert_or_panic(v[108] == 62);
	6479	assert_or_panic(v[109] == 63);
	6480	assert_or_panic(v[110] == 64);
	6481	assert_or_panic(v[111] == 65);
	6482	assert_or_panic(v[112] == 66);
	6483	assert_or_panic(v[113] == 67);
	6484	assert_or_panic(v[114] == 68);
	6485	assert_or_panic(v[115] == 69);
	6486	assert_or_panic(v[116] == 70);
	6487	assert_or_panic(v[117] == 71);
	6488	assert_or_panic(v[118] == 72);
	6489	assert_or_panic(v[119] == 73);
	6490	assert_or_panic(v[120] == 74);
	6491	assert_or_panic(v[121] == 75);
	6492	assert_or_panic(v[122] == 76);
	6493	assert_or_panic(v[123] == 77);
	6494	assert_or_panic(v[124] == 78);
	6495	assert_or_panic(v[125] == 79);
	6496	assert_or_panic(v[126] == 80);
	6497	assert_or_panic(v[127] == 81);
	6498	assert_or_panic(v[128] == 82);
	6499	assert_or_panic(v[129] == 83);
	6500	assert_or_panic(v[130] == 84);
	6501	assert_or_panic(v[131] == 85);
	6502	assert_or_panic(v[132] == 86);
	6503	assert_or_panic(v[133] == 87);
	6504	assert_or_panic(v[134] == 88);
	6505	assert_or_panic(v[135] == 89);
	6506	assert_or_panic(v[136] == 90);
	6507	assert_or_panic(v[137] == 91);
	6508	assert_or_panic(v[138] == 92);
	6509	assert_or_panic(v[139] == 93);
	6510	assert_or_panic(v[140] == 94);
	6511	assert_or_panic(v[141] == 95);
	6512	assert_or_panic(v[142] == 96);
	6513	assert_or_panic(v[143] == 97);
	6514	assert_or_panic(v[144] == 98);
	6515	assert_or_panic(v[145] == 99);
	6516	assert_or_panic(v[146] == 0);
	6517	assert_or_panic(v[147] == 1);
	6518	assert_or_panic(v[148] == 2);
	6519	assert_or_panic(v[149] == 3);
	6520	assert_or_panic(v[150] == 4);
	6521	assert_or_panic(v[151] == 5);
	6522	assert_or_panic(v[152] == 6);
	6523	assert_or_panic(v[153] == 7);
	6524	assert_or_panic(v[154] == 8);
	6525	assert_or_panic(v[155] == 9);
	6526	assert_or_panic(v[156] == 10);
	6527	assert_or_panic(v[157] == 11);
	6528	assert_or_panic(v[158] == 12);
	6529	assert_or_panic(v[159] == 13);
	6530	assert_or_panic(v[160] == 14);
	6531	assert_or_panic(v[161] == 15);
	6532	assert_or_panic(v[162] == 16);
	6533	assert_or_panic(v[163] == 17);
	6534	assert_or_panic(v[164] == 18);
	6535	assert_or_panic(v[165] == 19);
	6536	assert_or_panic(v[166] == 20);
	6537	assert_or_panic(v[167] == 21);
	6538	assert_or_panic(v[168] == 22);
	6539	assert_or_panic(v[169] == 23);
	6540	assert_or_panic(v[170] == 24);
	6541	assert_or_panic(v[171] == 25);
	6542	assert_or_panic(v[172] == 26);
	6543	assert_or_panic(v[173] == 27);
	6544	assert_or_panic(v[174] == 28);
	6545	assert_or_panic(v[175] == 29);
	6546	assert_or_panic(v[176] == 30);
	6547	assert_or_panic(v[177] == 31);
	6548	assert_or_panic(v[178] == 32);
	6549	assert_or_panic(v[179] == 33);
	6550	assert_or_panic(v[180] == 34);
	6551	assert_or_panic(v[181] == 35);
	6552	assert_or_panic(v[182] == 36);
	6553	assert_or_panic(v[183] == 37);
	6554	assert_or_panic(v[184] == 38);
	6555	assert_or_panic(v[185] == 39);
	6556	assert_or_panic(v[186] == 40);
	6557	assert_or_panic(v[187] == 41);
	6558	assert_or_panic(v[188] == 42);
	6559	assert_or_panic(v[189] == 43);
	6560	assert_or_panic(v[190] == 44);
	6561	assert_or_panic(v[191] == 45);
	6562	assert_or_panic(v[192] == 46);
	6563	assert_or_panic(v[193] == 47);
	6564	assert_or_panic(v[194] == 48);
	6565	assert_or_panic(v[195] == 49);
	6566	assert_or_panic(v[196] == 50);
	6567	assert_or_panic(v[197] == 51);
	6568	assert_or_panic(v[198] == 52);
	6569	assert_or_panic(v[199] == 53);
	6570	assert_or_panic(v[200] == 54);
	6571	assert_or_panic(v[201] == 55);
	6572	assert_or_panic(v[202] == 56);
	6573	assert_or_panic(v[203] == 57);
	6574	assert_or_panic(v[204] == 58);
	6575	assert_or_panic(v[205] == 59);
	6576	assert_or_panic(v[206] == 60);
	6577	assert_or_panic(v[207] == 61);
	6578	assert_or_panic(v[208] == 62);
	6579	assert_or_panic(v[209] == 63);
	6580	assert_or_panic(v[210] == 64);
	6581	assert_or_panic(v[211] == 65);
	6582	assert_or_panic(v[212] == 66);
	6583	assert_or_panic(v[213] == 67);
	6584	assert_or_panic(v[214] == 68);
	6585	assert_or_panic(v[215] == 69);
	6586	assert_or_panic(v[216] == 70);
	6587	assert_or_panic(v[217] == 71);
	6588	assert_or_panic(v[218] == 72);
	6589	assert_or_panic(v[219] == 73);
	6590	assert_or_panic(v[220] == 74);
	6591	assert_or_panic(v[221] == 75);
	6592	assert_or_panic(v[222] == 76);
	6593	assert_or_panic(v[223] == 77);
	6594	assert_or_panic(v[224] == 78);
	6595	assert_or_panic(v[225] == 79);
	6596	assert_or_panic(v[226] == 80);
	6597	assert_or_panic(v[227] == 81);
	6598	assert_or_panic(v[228] == 82);
	6599	assert_or_panic(v[229] == 83);
	6600	assert_or_panic(v[230] == 84);
	6601	assert_or_panic(v[231] == 85);
	6602	assert_or_panic(v[232] == 86);
	6603	assert_or_panic(v[233] == 87);
	6604	assert_or_panic(v[234] == 88);
	6605	assert_or_panic(v[235] == 89);
	6606	assert_or_panic(v[236] == 90);
	6607	assert_or_panic(v[237] == 91);
	6608	assert_or_panic(v[238] == 92);
	6609	assert_or_panic(v[239] == 93);
	6610	assert_or_panic(v[240] == 94);
	6611	assert_or_panic(v[241] == 95);
	6612	assert_or_panic(v[242] == 96);
	6613	assert_or_panic(v[243] == 97);
	6614	assert_or_panic(v[244] == 98);
	6615	assert_or_panic(v[245] == 99);
	6616	assert_or_panic(v[246] == 0);
	6617	assert_or_panic(v[247] == 1);
	6618	assert_or_panic(v[248] == 2);
	6619	assert_or_panic(v[249] == 3);
	6620	assert_or_panic(v[250] == 4);
	6621	assert_or_panic(v[251] == 5);
	6622	assert_or_panic(v[252] == 6);
	6623	assert_or_panic(v[253] == 7);
	6624	assert_or_panic(v[254] == 8);
	6625	assert_or_panic(v[255] == 9);
	6626	zig_vector_256_u8((Vector_256_u8){
	6627	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	6628	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	6629	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	6630	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	6631	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	6632	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	6633	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	6634	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	6635	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	6636	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	6637	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	6638	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	6639	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	6640	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	6641	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	6642	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	6643	}, 256);
	6644	}
	6645
	6646	typedef uint8_t Vector_384_u8 __attribute__((vector_size(384 * sizeof(uint8_t))));
	6647
	6648	Vector_384_u8 zig_ret_vector_384_u8(void);
	6649	void zig_vector_384_u8(Vector_384_u8, size_t);
	6650
	6651	Vector_384_u8 c_ret_vector_384_u8(void) {
	6652	return (Vector_384_u8){
	6653	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	6654	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	6655	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	6656	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	6657	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	6658	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	6659	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	6660	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	6661	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	6662	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	6663	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	6664	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	6665	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	6666	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	6667	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	6668	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	6669	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	6670	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	6671	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	6672	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	6673	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	6674	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	6675	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	6676	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	6677	};
	6678	}
	6679	void c_vector_384_u8(Vector_384_u8 v, size_t i) {
	6680	assert_or_panic(v[0] == 30);
	6681	assert_or_panic(v[1] == 31);
	6682	assert_or_panic(v[2] == 32);
	6683	assert_or_panic(v[3] == 33);
	6684	assert_or_panic(v[4] == 34);
	6685	assert_or_panic(v[5] == 35);
	6686	assert_or_panic(v[6] == 36);
	6687	assert_or_panic(v[7] == 37);
	6688	assert_or_panic(v[8] == 38);
	6689	assert_or_panic(v[9] == 39);
	6690	assert_or_panic(v[10] == 40);
	6691	assert_or_panic(v[11] == 41);
	6692	assert_or_panic(v[12] == 42);
	6693	assert_or_panic(v[13] == 43);
	6694	assert_or_panic(v[14] == 44);
	6695	assert_or_panic(v[15] == 45);
	6696	assert_or_panic(v[16] == 46);
	6697	assert_or_panic(v[17] == 47);
	6698	assert_or_panic(v[18] == 48);
	6699	assert_or_panic(v[19] == 49);
	6700	assert_or_panic(v[20] == 50);
	6701	assert_or_panic(v[21] == 51);
	6702	assert_or_panic(v[22] == 52);
	6703	assert_or_panic(v[23] == 53);
	6704	assert_or_panic(v[24] == 54);
	6705	assert_or_panic(v[25] == 55);
	6706	assert_or_panic(v[26] == 56);
	6707	assert_or_panic(v[27] == 57);
	6708	assert_or_panic(v[28] == 58);
	6709	assert_or_panic(v[29] == 59);
	6710	assert_or_panic(v[30] == 60);
	6711	assert_or_panic(v[31] == 61);
	6712	assert_or_panic(v[32] == 62);
	6713	assert_or_panic(v[33] == 63);
	6714	assert_or_panic(v[34] == 64);
	6715	assert_or_panic(v[35] == 65);
	6716	assert_or_panic(v[36] == 66);
	6717	assert_or_panic(v[37] == 67);
	6718	assert_or_panic(v[38] == 68);
	6719	assert_or_panic(v[39] == 69);
	6720	assert_or_panic(v[40] == 70);
	6721	assert_or_panic(v[41] == 71);
	6722	assert_or_panic(v[42] == 72);
	6723	assert_or_panic(v[43] == 73);
	6724	assert_or_panic(v[44] == 74);
	6725	assert_or_panic(v[45] == 75);
	6726	assert_or_panic(v[46] == 76);
	6727	assert_or_panic(v[47] == 77);
	6728	assert_or_panic(v[48] == 78);
	6729	assert_or_panic(v[49] == 79);
	6730	assert_or_panic(v[50] == 80);
	6731	assert_or_panic(v[51] == 81);
	6732	assert_or_panic(v[52] == 82);
	6733	assert_or_panic(v[53] == 83);
	6734	assert_or_panic(v[54] == 84);
	6735	assert_or_panic(v[55] == 85);
	6736	assert_or_panic(v[56] == 86);
	6737	assert_or_panic(v[57] == 87);
	6738	assert_or_panic(v[58] == 88);
	6739	assert_or_panic(v[59] == 89);
	6740	assert_or_panic(v[60] == 90);
	6741	assert_or_panic(v[61] == 91);
	6742	assert_or_panic(v[62] == 92);
	6743	assert_or_panic(v[63] == 93);
	6744	assert_or_panic(v[64] == 94);
	6745	assert_or_panic(v[65] == 95);
	6746	assert_or_panic(v[66] == 96);
	6747	assert_or_panic(v[67] == 97);
	6748	assert_or_panic(v[68] == 98);
	6749	assert_or_panic(v[69] == 99);
	6750	assert_or_panic(v[70] == 0);
	6751	assert_or_panic(v[71] == 1);
	6752	assert_or_panic(v[72] == 2);
	6753	assert_or_panic(v[73] == 3);
	6754	assert_or_panic(v[74] == 4);
	6755	assert_or_panic(v[75] == 5);
	6756	assert_or_panic(v[76] == 6);
	6757	assert_or_panic(v[77] == 7);
	6758	assert_or_panic(v[78] == 8);
	6759	assert_or_panic(v[79] == 9);
	6760	assert_or_panic(v[80] == 10);
	6761	assert_or_panic(v[81] == 11);
	6762	assert_or_panic(v[82] == 12);
	6763	assert_or_panic(v[83] == 13);
	6764	assert_or_panic(v[84] == 14);
	6765	assert_or_panic(v[85] == 15);
	6766	assert_or_panic(v[86] == 16);
	6767	assert_or_panic(v[87] == 17);
	6768	assert_or_panic(v[88] == 18);
	6769	assert_or_panic(v[89] == 19);
	6770	assert_or_panic(v[90] == 20);
	6771	assert_or_panic(v[91] == 21);
	6772	assert_or_panic(v[92] == 22);
	6773	assert_or_panic(v[93] == 23);
	6774	assert_or_panic(v[94] == 24);
	6775	assert_or_panic(v[95] == 25);
	6776	assert_or_panic(v[96] == 26);
	6777	assert_or_panic(v[97] == 27);
	6778	assert_or_panic(v[98] == 28);
	6779	assert_or_panic(v[99] == 29);
	6780	assert_or_panic(v[100] == 30);
	6781	assert_or_panic(v[101] == 31);
	6782	assert_or_panic(v[102] == 32);
	6783	assert_or_panic(v[103] == 33);
	6784	assert_or_panic(v[104] == 34);
	6785	assert_or_panic(v[105] == 35);
	6786	assert_or_panic(v[106] == 36);
	6787	assert_or_panic(v[107] == 37);
	6788	assert_or_panic(v[108] == 38);
	6789	assert_or_panic(v[109] == 39);
	6790	assert_or_panic(v[110] == 40);
	6791	assert_or_panic(v[111] == 41);
	6792	assert_or_panic(v[112] == 42);
	6793	assert_or_panic(v[113] == 43);
	6794	assert_or_panic(v[114] == 44);
	6795	assert_or_panic(v[115] == 45);
	6796	assert_or_panic(v[116] == 46);
	6797	assert_or_panic(v[117] == 47);
	6798	assert_or_panic(v[118] == 48);
	6799	assert_or_panic(v[119] == 49);
	6800	assert_or_panic(v[120] == 50);
	6801	assert_or_panic(v[121] == 51);
	6802	assert_or_panic(v[122] == 52);
	6803	assert_or_panic(v[123] == 53);
	6804	assert_or_panic(v[124] == 54);
	6805	assert_or_panic(v[125] == 55);
	6806	assert_or_panic(v[126] == 56);
	6807	assert_or_panic(v[127] == 57);
	6808	assert_or_panic(v[128] == 58);
	6809	assert_or_panic(v[129] == 59);
	6810	assert_or_panic(v[130] == 60);
	6811	assert_or_panic(v[131] == 61);
	6812	assert_or_panic(v[132] == 62);
	6813	assert_or_panic(v[133] == 63);
	6814	assert_or_panic(v[134] == 64);
	6815	assert_or_panic(v[135] == 65);
	6816	assert_or_panic(v[136] == 66);
	6817	assert_or_panic(v[137] == 67);
	6818	assert_or_panic(v[138] == 68);
	6819	assert_or_panic(v[139] == 69);
	6820	assert_or_panic(v[140] == 70);
	6821	assert_or_panic(v[141] == 71);
	6822	assert_or_panic(v[142] == 72);
	6823	assert_or_panic(v[143] == 73);
	6824	assert_or_panic(v[144] == 74);
	6825	assert_or_panic(v[145] == 75);
	6826	assert_or_panic(v[146] == 76);
	6827	assert_or_panic(v[147] == 77);
	6828	assert_or_panic(v[148] == 78);
	6829	assert_or_panic(v[149] == 79);
	6830	assert_or_panic(v[150] == 80);
	6831	assert_or_panic(v[151] == 81);
	6832	assert_or_panic(v[152] == 82);
	6833	assert_or_panic(v[153] == 83);
	6834	assert_or_panic(v[154] == 84);
	6835	assert_or_panic(v[155] == 85);
	6836	assert_or_panic(v[156] == 86);
	6837	assert_or_panic(v[157] == 87);
	6838	assert_or_panic(v[158] == 88);
	6839	assert_or_panic(v[159] == 89);
	6840	assert_or_panic(v[160] == 90);
	6841	assert_or_panic(v[161] == 91);
	6842	assert_or_panic(v[162] == 92);
	6843	assert_or_panic(v[163] == 93);
	6844	assert_or_panic(v[164] == 94);
	6845	assert_or_panic(v[165] == 95);
	6846	assert_or_panic(v[166] == 96);
	6847	assert_or_panic(v[167] == 97);
	6848	assert_or_panic(v[168] == 98);
	6849	assert_or_panic(v[169] == 99);
	6850	assert_or_panic(v[170] == 0);
	6851	assert_or_panic(v[171] == 1);
	6852	assert_or_panic(v[172] == 2);
	6853	assert_or_panic(v[173] == 3);
	6854	assert_or_panic(v[174] == 4);
	6855	assert_or_panic(v[175] == 5);
	6856	assert_or_panic(v[176] == 6);
	6857	assert_or_panic(v[177] == 7);
	6858	assert_or_panic(v[178] == 8);
	6859	assert_or_panic(v[179] == 9);
	6860	assert_or_panic(v[180] == 10);
	6861	assert_or_panic(v[181] == 11);
	6862	assert_or_panic(v[182] == 12);
	6863	assert_or_panic(v[183] == 13);
	6864	assert_or_panic(v[184] == 14);
	6865	assert_or_panic(v[185] == 15);
	6866	assert_or_panic(v[186] == 16);
	6867	assert_or_panic(v[187] == 17);
	6868	assert_or_panic(v[188] == 18);
	6869	assert_or_panic(v[189] == 19);
	6870	assert_or_panic(v[190] == 20);
	6871	assert_or_panic(v[191] == 21);
	6872	assert_or_panic(v[192] == 22);
	6873	assert_or_panic(v[193] == 23);
	6874	assert_or_panic(v[194] == 24);
	6875	assert_or_panic(v[195] == 25);
	6876	assert_or_panic(v[196] == 26);
	6877	assert_or_panic(v[197] == 27);
	6878	assert_or_panic(v[198] == 28);
	6879	assert_or_panic(v[199] == 29);
	6880	assert_or_panic(v[200] == 30);
	6881	assert_or_panic(v[201] == 31);
	6882	assert_or_panic(v[202] == 32);
	6883	assert_or_panic(v[203] == 33);
	6884	assert_or_panic(v[204] == 34);
	6885	assert_or_panic(v[205] == 35);
	6886	assert_or_panic(v[206] == 36);
	6887	assert_or_panic(v[207] == 37);
	6888	assert_or_panic(v[208] == 38);
	6889	assert_or_panic(v[209] == 39);
	6890	assert_or_panic(v[210] == 40);
	6891	assert_or_panic(v[211] == 41);
	6892	assert_or_panic(v[212] == 42);
	6893	assert_or_panic(v[213] == 43);
	6894	assert_or_panic(v[214] == 44);
	6895	assert_or_panic(v[215] == 45);
	6896	assert_or_panic(v[216] == 46);
	6897	assert_or_panic(v[217] == 47);
	6898	assert_or_panic(v[218] == 48);
	6899	assert_or_panic(v[219] == 49);
	6900	assert_or_panic(v[220] == 50);
	6901	assert_or_panic(v[221] == 51);
	6902	assert_or_panic(v[222] == 52);
	6903	assert_or_panic(v[223] == 53);
	6904	assert_or_panic(v[224] == 54);
	6905	assert_or_panic(v[225] == 55);
	6906	assert_or_panic(v[226] == 56);
	6907	assert_or_panic(v[227] == 57);
	6908	assert_or_panic(v[228] == 58);
	6909	assert_or_panic(v[229] == 59);
	6910	assert_or_panic(v[230] == 60);
	6911	assert_or_panic(v[231] == 61);
	6912	assert_or_panic(v[232] == 62);
	6913	assert_or_panic(v[233] == 63);
	6914	assert_or_panic(v[234] == 64);
	6915	assert_or_panic(v[235] == 65);
	6916	assert_or_panic(v[236] == 66);
	6917	assert_or_panic(v[237] == 67);
	6918	assert_or_panic(v[238] == 68);
	6919	assert_or_panic(v[239] == 69);
	6920	assert_or_panic(v[240] == 70);
	6921	assert_or_panic(v[241] == 71);
	6922	assert_or_panic(v[242] == 72);
	6923	assert_or_panic(v[243] == 73);
	6924	assert_or_panic(v[244] == 74);
	6925	assert_or_panic(v[245] == 75);
	6926	assert_or_panic(v[246] == 76);
	6927	assert_or_panic(v[247] == 77);
	6928	assert_or_panic(v[248] == 78);
	6929	assert_or_panic(v[249] == 79);
	6930	assert_or_panic(v[250] == 80);
	6931	assert_or_panic(v[251] == 81);
	6932	assert_or_panic(v[252] == 82);
	6933	assert_or_panic(v[253] == 83);
	6934	assert_or_panic(v[254] == 84);
	6935	assert_or_panic(v[255] == 85);
	6936	assert_or_panic(v[256] == 86);
	6937	assert_or_panic(v[257] == 87);
	6938	assert_or_panic(v[258] == 88);
	6939	assert_or_panic(v[259] == 89);
	6940	assert_or_panic(v[260] == 90);
	6941	assert_or_panic(v[261] == 91);
	6942	assert_or_panic(v[262] == 92);
	6943	assert_or_panic(v[263] == 93);
	6944	assert_or_panic(v[264] == 94);
	6945	assert_or_panic(v[265] == 95);
	6946	assert_or_panic(v[266] == 96);
	6947	assert_or_panic(v[267] == 97);
	6948	assert_or_panic(v[268] == 98);
	6949	assert_or_panic(v[269] == 99);
	6950	assert_or_panic(v[270] == 0);
	6951	assert_or_panic(v[271] == 1);
	6952	assert_or_panic(v[272] == 2);
	6953	assert_or_panic(v[273] == 3);
	6954	assert_or_panic(v[274] == 4);
	6955	assert_or_panic(v[275] == 5);
	6956	assert_or_panic(v[276] == 6);
	6957	assert_or_panic(v[277] == 7);
	6958	assert_or_panic(v[278] == 8);
	6959	assert_or_panic(v[279] == 9);
	6960	assert_or_panic(v[280] == 10);
	6961	assert_or_panic(v[281] == 11);
	6962	assert_or_panic(v[282] == 12);
	6963	assert_or_panic(v[283] == 13);
	6964	assert_or_panic(v[284] == 14);
	6965	assert_or_panic(v[285] == 15);
	6966	assert_or_panic(v[286] == 16);
	6967	assert_or_panic(v[287] == 17);
	6968	assert_or_panic(v[288] == 18);
	6969	assert_or_panic(v[289] == 19);
	6970	assert_or_panic(v[290] == 20);
	6971	assert_or_panic(v[291] == 21);
	6972	assert_or_panic(v[292] == 22);
	6973	assert_or_panic(v[293] == 23);
	6974	assert_or_panic(v[294] == 24);
	6975	assert_or_panic(v[295] == 25);
	6976	assert_or_panic(v[296] == 26);
	6977	assert_or_panic(v[297] == 27);
	6978	assert_or_panic(v[298] == 28);
	6979	assert_or_panic(v[299] == 29);
	6980	assert_or_panic(v[300] == 30);
	6981	assert_or_panic(v[301] == 31);
	6982	assert_or_panic(v[302] == 32);
	6983	assert_or_panic(v[303] == 33);
	6984	assert_or_panic(v[304] == 34);
	6985	assert_or_panic(v[305] == 35);
	6986	assert_or_panic(v[306] == 36);
	6987	assert_or_panic(v[307] == 37);
	6988	assert_or_panic(v[308] == 38);
	6989	assert_or_panic(v[309] == 39);
	6990	assert_or_panic(v[310] == 40);
	6991	assert_or_panic(v[311] == 41);
	6992	assert_or_panic(v[312] == 42);
	6993	assert_or_panic(v[313] == 43);
	6994	assert_or_panic(v[314] == 44);
	6995	assert_or_panic(v[315] == 45);
	6996	assert_or_panic(v[316] == 46);
	6997	assert_or_panic(v[317] == 47);
	6998	assert_or_panic(v[318] == 48);
	6999	assert_or_panic(v[319] == 49);
	7000	assert_or_panic(v[320] == 50);
	7001	assert_or_panic(v[321] == 51);
	7002	assert_or_panic(v[322] == 52);
	7003	assert_or_panic(v[323] == 53);
	7004	assert_or_panic(v[324] == 54);
	7005	assert_or_panic(v[325] == 55);
	7006	assert_or_panic(v[326] == 56);
	7007	assert_or_panic(v[327] == 57);
	7008	assert_or_panic(v[328] == 58);
	7009	assert_or_panic(v[329] == 59);
	7010	assert_or_panic(v[330] == 60);
	7011	assert_or_panic(v[331] == 61);
	7012	assert_or_panic(v[332] == 62);
	7013	assert_or_panic(v[333] == 63);
	7014	assert_or_panic(v[334] == 64);
	7015	assert_or_panic(v[335] == 65);
	7016	assert_or_panic(v[336] == 66);
	7017	assert_or_panic(v[337] == 67);
	7018	assert_or_panic(v[338] == 68);
	7019	assert_or_panic(v[339] == 69);
	7020	assert_or_panic(v[340] == 70);
	7021	assert_or_panic(v[341] == 71);
	7022	assert_or_panic(v[342] == 72);
	7023	assert_or_panic(v[343] == 73);
	7024	assert_or_panic(v[344] == 74);
	7025	assert_or_panic(v[345] == 75);
	7026	assert_or_panic(v[346] == 76);
	7027	assert_or_panic(v[347] == 77);
	7028	assert_or_panic(v[348] == 78);
	7029	assert_or_panic(v[349] == 79);
	7030	assert_or_panic(v[350] == 80);
	7031	assert_or_panic(v[351] == 81);
	7032	assert_or_panic(v[352] == 82);
	7033	assert_or_panic(v[353] == 83);
	7034	assert_or_panic(v[354] == 84);
	7035	assert_or_panic(v[355] == 85);
	7036	assert_or_panic(v[356] == 86);
	7037	assert_or_panic(v[357] == 87);
	7038	assert_or_panic(v[358] == 88);
	7039	assert_or_panic(v[359] == 89);
	7040	assert_or_panic(v[360] == 90);
	7041	assert_or_panic(v[361] == 91);
	7042	assert_or_panic(v[362] == 92);
	7043	assert_or_panic(v[363] == 93);
	7044	assert_or_panic(v[364] == 94);
	7045	assert_or_panic(v[365] == 95);
	7046	assert_or_panic(v[366] == 96);
	7047	assert_or_panic(v[367] == 97);
	7048	assert_or_panic(v[368] == 98);
	7049	assert_or_panic(v[369] == 99);
	7050	assert_or_panic(v[370] == 0);
	7051	assert_or_panic(v[371] == 1);
	7052	assert_or_panic(v[372] == 2);
	7053	assert_or_panic(v[373] == 3);
	7054	assert_or_panic(v[374] == 4);
	7055	assert_or_panic(v[375] == 5);
	7056	assert_or_panic(v[376] == 6);
	7057	assert_or_panic(v[377] == 7);
	7058	assert_or_panic(v[378] == 8);
	7059	assert_or_panic(v[379] == 9);
	7060	assert_or_panic(v[380] == 10);
	7061	assert_or_panic(v[381] == 11);
	7062	assert_or_panic(v[382] == 12);
	7063	assert_or_panic(v[383] == 13);
	7064	assert_or_panic(i == 384);
	7065	}
	7066	void c_test_vector_384_u8(void) {
	7067	Vector_384_u8 v = zig_ret_vector_384_u8();
	7068	assert_or_panic(v[0] == 78);
	7069	assert_or_panic(v[1] == 79);
	7070	assert_or_panic(v[2] == 80);
	7071	assert_or_panic(v[3] == 81);
	7072	assert_or_panic(v[4] == 82);
	7073	assert_or_panic(v[5] == 83);
	7074	assert_or_panic(v[6] == 84);
	7075	assert_or_panic(v[7] == 85);
	7076	assert_or_panic(v[8] == 86);
	7077	assert_or_panic(v[9] == 87);
	7078	assert_or_panic(v[10] == 88);
	7079	assert_or_panic(v[11] == 89);
	7080	assert_or_panic(v[12] == 90);
	7081	assert_or_panic(v[13] == 91);
	7082	assert_or_panic(v[14] == 92);
	7083	assert_or_panic(v[15] == 93);
	7084	assert_or_panic(v[16] == 94);
	7085	assert_or_panic(v[17] == 95);
	7086	assert_or_panic(v[18] == 96);
	7087	assert_or_panic(v[19] == 97);
	7088	assert_or_panic(v[20] == 98);
	7089	assert_or_panic(v[21] == 99);
	7090	assert_or_panic(v[22] == 0);
	7091	assert_or_panic(v[23] == 1);
	7092	assert_or_panic(v[24] == 2);
	7093	assert_or_panic(v[25] == 3);
	7094	assert_or_panic(v[26] == 4);
	7095	assert_or_panic(v[27] == 5);
	7096	assert_or_panic(v[28] == 6);
	7097	assert_or_panic(v[29] == 7);
	7098	assert_or_panic(v[30] == 8);
	7099	assert_or_panic(v[31] == 9);
	7100	assert_or_panic(v[32] == 10);
	7101	assert_or_panic(v[33] == 11);
	7102	assert_or_panic(v[34] == 12);
	7103	assert_or_panic(v[35] == 13);
	7104	assert_or_panic(v[36] == 14);
	7105	assert_or_panic(v[37] == 15);
	7106	assert_or_panic(v[38] == 16);
	7107	assert_or_panic(v[39] == 17);
	7108	assert_or_panic(v[40] == 18);
	7109	assert_or_panic(v[41] == 19);
	7110	assert_or_panic(v[42] == 20);
	7111	assert_or_panic(v[43] == 21);
	7112	assert_or_panic(v[44] == 22);
	7113	assert_or_panic(v[45] == 23);
	7114	assert_or_panic(v[46] == 24);
	7115	assert_or_panic(v[47] == 25);
	7116	assert_or_panic(v[48] == 26);
	7117	assert_or_panic(v[49] == 27);
	7118	assert_or_panic(v[50] == 28);
	7119	assert_or_panic(v[51] == 29);
	7120	assert_or_panic(v[52] == 30);
	7121	assert_or_panic(v[53] == 31);
	7122	assert_or_panic(v[54] == 32);
	7123	assert_or_panic(v[55] == 33);
	7124	assert_or_panic(v[56] == 34);
	7125	assert_or_panic(v[57] == 35);
	7126	assert_or_panic(v[58] == 36);
	7127	assert_or_panic(v[59] == 37);
	7128	assert_or_panic(v[60] == 38);
	7129	assert_or_panic(v[61] == 39);
	7130	assert_or_panic(v[62] == 40);
	7131	assert_or_panic(v[63] == 41);
	7132	assert_or_panic(v[64] == 42);
	7133	assert_or_panic(v[65] == 43);
	7134	assert_or_panic(v[66] == 44);
	7135	assert_or_panic(v[67] == 45);
	7136	assert_or_panic(v[68] == 46);
	7137	assert_or_panic(v[69] == 47);
	7138	assert_or_panic(v[70] == 48);
	7139	assert_or_panic(v[71] == 49);
	7140	assert_or_panic(v[72] == 50);
	7141	assert_or_panic(v[73] == 51);
	7142	assert_or_panic(v[74] == 52);
	7143	assert_or_panic(v[75] == 53);
	7144	assert_or_panic(v[76] == 54);
	7145	assert_or_panic(v[77] == 55);
	7146	assert_or_panic(v[78] == 56);
	7147	assert_or_panic(v[79] == 57);
	7148	assert_or_panic(v[80] == 58);
	7149	assert_or_panic(v[81] == 59);
	7150	assert_or_panic(v[82] == 60);
	7151	assert_or_panic(v[83] == 61);
	7152	assert_or_panic(v[84] == 62);
	7153	assert_or_panic(v[85] == 63);
	7154	assert_or_panic(v[86] == 64);
	7155	assert_or_panic(v[87] == 65);
	7156	assert_or_panic(v[88] == 66);
	7157	assert_or_panic(v[89] == 67);
	7158	assert_or_panic(v[90] == 68);
	7159	assert_or_panic(v[91] == 69);
	7160	assert_or_panic(v[92] == 70);
	7161	assert_or_panic(v[93] == 71);
	7162	assert_or_panic(v[94] == 72);
	7163	assert_or_panic(v[95] == 73);
	7164	assert_or_panic(v[96] == 74);
	7165	assert_or_panic(v[97] == 75);
	7166	assert_or_panic(v[98] == 76);
	7167	assert_or_panic(v[99] == 77);
	7168	assert_or_panic(v[100] == 78);
	7169	assert_or_panic(v[101] == 79);
	7170	assert_or_panic(v[102] == 80);
	7171	assert_or_panic(v[103] == 81);
	7172	assert_or_panic(v[104] == 82);
	7173	assert_or_panic(v[105] == 83);
	7174	assert_or_panic(v[106] == 84);
	7175	assert_or_panic(v[107] == 85);
	7176	assert_or_panic(v[108] == 86);
	7177	assert_or_panic(v[109] == 87);
	7178	assert_or_panic(v[110] == 88);
	7179	assert_or_panic(v[111] == 89);
	7180	assert_or_panic(v[112] == 90);
	7181	assert_or_panic(v[113] == 91);
	7182	assert_or_panic(v[114] == 92);
	7183	assert_or_panic(v[115] == 93);
	7184	assert_or_panic(v[116] == 94);
	7185	assert_or_panic(v[117] == 95);
	7186	assert_or_panic(v[118] == 96);
	7187	assert_or_panic(v[119] == 97);
	7188	assert_or_panic(v[120] == 98);
	7189	assert_or_panic(v[121] == 99);
	7190	assert_or_panic(v[122] == 0);
	7191	assert_or_panic(v[123] == 1);
	7192	assert_or_panic(v[124] == 2);
	7193	assert_or_panic(v[125] == 3);
	7194	assert_or_panic(v[126] == 4);
	7195	assert_or_panic(v[127] == 5);
	7196	assert_or_panic(v[128] == 6);
	7197	assert_or_panic(v[129] == 7);
	7198	assert_or_panic(v[130] == 8);
	7199	assert_or_panic(v[131] == 9);
	7200	assert_or_panic(v[132] == 10);
	7201	assert_or_panic(v[133] == 11);
	7202	assert_or_panic(v[134] == 12);
	7203	assert_or_panic(v[135] == 13);
	7204	assert_or_panic(v[136] == 14);
	7205	assert_or_panic(v[137] == 15);
	7206	assert_or_panic(v[138] == 16);
	7207	assert_or_panic(v[139] == 17);
	7208	assert_or_panic(v[140] == 18);
	7209	assert_or_panic(v[141] == 19);
	7210	assert_or_panic(v[142] == 20);
	7211	assert_or_panic(v[143] == 21);
	7212	assert_or_panic(v[144] == 22);
	7213	assert_or_panic(v[145] == 23);
	7214	assert_or_panic(v[146] == 24);
	7215	assert_or_panic(v[147] == 25);
	7216	assert_or_panic(v[148] == 26);
	7217	assert_or_panic(v[149] == 27);
	7218	assert_or_panic(v[150] == 28);
	7219	assert_or_panic(v[151] == 29);
	7220	assert_or_panic(v[152] == 30);
	7221	assert_or_panic(v[153] == 31);
	7222	assert_or_panic(v[154] == 32);
	7223	assert_or_panic(v[155] == 33);
	7224	assert_or_panic(v[156] == 34);
	7225	assert_or_panic(v[157] == 35);
	7226	assert_or_panic(v[158] == 36);
	7227	assert_or_panic(v[159] == 37);
	7228	assert_or_panic(v[160] == 38);
	7229	assert_or_panic(v[161] == 39);
	7230	assert_or_panic(v[162] == 40);
	7231	assert_or_panic(v[163] == 41);
	7232	assert_or_panic(v[164] == 42);
	7233	assert_or_panic(v[165] == 43);
	7234	assert_or_panic(v[166] == 44);
	7235	assert_or_panic(v[167] == 45);
	7236	assert_or_panic(v[168] == 46);
	7237	assert_or_panic(v[169] == 47);
	7238	assert_or_panic(v[170] == 48);
	7239	assert_or_panic(v[171] == 49);
	7240	assert_or_panic(v[172] == 50);
	7241	assert_or_panic(v[173] == 51);
	7242	assert_or_panic(v[174] == 52);
	7243	assert_or_panic(v[175] == 53);
	7244	assert_or_panic(v[176] == 54);
	7245	assert_or_panic(v[177] == 55);
	7246	assert_or_panic(v[178] == 56);
	7247	assert_or_panic(v[179] == 57);
	7248	assert_or_panic(v[180] == 58);
	7249	assert_or_panic(v[181] == 59);
	7250	assert_or_panic(v[182] == 60);
	7251	assert_or_panic(v[183] == 61);
	7252	assert_or_panic(v[184] == 62);
	7253	assert_or_panic(v[185] == 63);
	7254	assert_or_panic(v[186] == 64);
	7255	assert_or_panic(v[187] == 65);
	7256	assert_or_panic(v[188] == 66);
	7257	assert_or_panic(v[189] == 67);
	7258	assert_or_panic(v[190] == 68);
	7259	assert_or_panic(v[191] == 69);
	7260	assert_or_panic(v[192] == 70);
	7261	assert_or_panic(v[193] == 71);
	7262	assert_or_panic(v[194] == 72);
	7263	assert_or_panic(v[195] == 73);
	7264	assert_or_panic(v[196] == 74);
	7265	assert_or_panic(v[197] == 75);
	7266	assert_or_panic(v[198] == 76);
	7267	assert_or_panic(v[199] == 77);
	7268	assert_or_panic(v[200] == 78);
	7269	assert_or_panic(v[201] == 79);
	7270	assert_or_panic(v[202] == 80);
	7271	assert_or_panic(v[203] == 81);
	7272	assert_or_panic(v[204] == 82);
	7273	assert_or_panic(v[205] == 83);
	7274	assert_or_panic(v[206] == 84);
	7275	assert_or_panic(v[207] == 85);
	7276	assert_or_panic(v[208] == 86);
	7277	assert_or_panic(v[209] == 87);
	7278	assert_or_panic(v[210] == 88);
	7279	assert_or_panic(v[211] == 89);
	7280	assert_or_panic(v[212] == 90);
	7281	assert_or_panic(v[213] == 91);
	7282	assert_or_panic(v[214] == 92);
	7283	assert_or_panic(v[215] == 93);
	7284	assert_or_panic(v[216] == 94);
	7285	assert_or_panic(v[217] == 95);
	7286	assert_or_panic(v[218] == 96);
	7287	assert_or_panic(v[219] == 97);
	7288	assert_or_panic(v[220] == 98);
	7289	assert_or_panic(v[221] == 99);
	7290	assert_or_panic(v[222] == 0);
	7291	assert_or_panic(v[223] == 1);
	7292	assert_or_panic(v[224] == 2);
	7293	assert_or_panic(v[225] == 3);
	7294	assert_or_panic(v[226] == 4);
	7295	assert_or_panic(v[227] == 5);
	7296	assert_or_panic(v[228] == 6);
	7297	assert_or_panic(v[229] == 7);
	7298	assert_or_panic(v[230] == 8);
	7299	assert_or_panic(v[231] == 9);
	7300	assert_or_panic(v[232] == 10);
	7301	assert_or_panic(v[233] == 11);
	7302	assert_or_panic(v[234] == 12);
	7303	assert_or_panic(v[235] == 13);
	7304	assert_or_panic(v[236] == 14);
	7305	assert_or_panic(v[237] == 15);
	7306	assert_or_panic(v[238] == 16);
	7307	assert_or_panic(v[239] == 17);
	7308	assert_or_panic(v[240] == 18);
	7309	assert_or_panic(v[241] == 19);
	7310	assert_or_panic(v[242] == 20);
	7311	assert_or_panic(v[243] == 21);
	7312	assert_or_panic(v[244] == 22);
	7313	assert_or_panic(v[245] == 23);
	7314	assert_or_panic(v[246] == 24);
	7315	assert_or_panic(v[247] == 25);
	7316	assert_or_panic(v[248] == 26);
	7317	assert_or_panic(v[249] == 27);
	7318	assert_or_panic(v[250] == 28);
	7319	assert_or_panic(v[251] == 29);
	7320	assert_or_panic(v[252] == 30);
	7321	assert_or_panic(v[253] == 31);
	7322	assert_or_panic(v[254] == 32);
	7323	assert_or_panic(v[255] == 33);
	7324	assert_or_panic(v[256] == 34);
	7325	assert_or_panic(v[257] == 35);
	7326	assert_or_panic(v[258] == 36);
	7327	assert_or_panic(v[259] == 37);
	7328	assert_or_panic(v[260] == 38);
	7329	assert_or_panic(v[261] == 39);
	7330	assert_or_panic(v[262] == 40);
	7331	assert_or_panic(v[263] == 41);
	7332	assert_or_panic(v[264] == 42);
	7333	assert_or_panic(v[265] == 43);
	7334	assert_or_panic(v[266] == 44);
	7335	assert_or_panic(v[267] == 45);
	7336	assert_or_panic(v[268] == 46);
	7337	assert_or_panic(v[269] == 47);
	7338	assert_or_panic(v[270] == 48);
	7339	assert_or_panic(v[271] == 49);
	7340	assert_or_panic(v[272] == 50);
	7341	assert_or_panic(v[273] == 51);
	7342	assert_or_panic(v[274] == 52);
	7343	assert_or_panic(v[275] == 53);
	7344	assert_or_panic(v[276] == 54);
	7345	assert_or_panic(v[277] == 55);
	7346	assert_or_panic(v[278] == 56);
	7347	assert_or_panic(v[279] == 57);
	7348	assert_or_panic(v[280] == 58);
	7349	assert_or_panic(v[281] == 59);
	7350	assert_or_panic(v[282] == 60);
	7351	assert_or_panic(v[283] == 61);
	7352	assert_or_panic(v[284] == 62);
	7353	assert_or_panic(v[285] == 63);
	7354	assert_or_panic(v[286] == 64);
	7355	assert_or_panic(v[287] == 65);
	7356	assert_or_panic(v[288] == 66);
	7357	assert_or_panic(v[289] == 67);
	7358	assert_or_panic(v[290] == 68);
	7359	assert_or_panic(v[291] == 69);
	7360	assert_or_panic(v[292] == 70);
	7361	assert_or_panic(v[293] == 71);
	7362	assert_or_panic(v[294] == 72);
	7363	assert_or_panic(v[295] == 73);
	7364	assert_or_panic(v[296] == 74);
	7365	assert_or_panic(v[297] == 75);
	7366	assert_or_panic(v[298] == 76);
	7367	assert_or_panic(v[299] == 77);
	7368	assert_or_panic(v[300] == 78);
	7369	assert_or_panic(v[301] == 79);
	7370	assert_or_panic(v[302] == 80);
	7371	assert_or_panic(v[303] == 81);
	7372	assert_or_panic(v[304] == 82);
	7373	assert_or_panic(v[305] == 83);
	7374	assert_or_panic(v[306] == 84);
	7375	assert_or_panic(v[307] == 85);
	7376	assert_or_panic(v[308] == 86);
	7377	assert_or_panic(v[309] == 87);
	7378	assert_or_panic(v[310] == 88);
	7379	assert_or_panic(v[311] == 89);
	7380	assert_or_panic(v[312] == 90);
	7381	assert_or_panic(v[313] == 91);
	7382	assert_or_panic(v[314] == 92);
	7383	assert_or_panic(v[315] == 93);
	7384	assert_or_panic(v[316] == 94);
	7385	assert_or_panic(v[317] == 95);
	7386	assert_or_panic(v[318] == 96);
	7387	assert_or_panic(v[319] == 97);
	7388	assert_or_panic(v[320] == 98);
	7389	assert_or_panic(v[321] == 99);
	7390	assert_or_panic(v[322] == 0);
	7391	assert_or_panic(v[323] == 1);
	7392	assert_or_panic(v[324] == 2);
	7393	assert_or_panic(v[325] == 3);
	7394	assert_or_panic(v[326] == 4);
	7395	assert_or_panic(v[327] == 5);
	7396	assert_or_panic(v[328] == 6);
	7397	assert_or_panic(v[329] == 7);
	7398	assert_or_panic(v[330] == 8);
	7399	assert_or_panic(v[331] == 9);
	7400	assert_or_panic(v[332] == 10);
	7401	assert_or_panic(v[333] == 11);
	7402	assert_or_panic(v[334] == 12);
	7403	assert_or_panic(v[335] == 13);
	7404	assert_or_panic(v[336] == 14);
	7405	assert_or_panic(v[337] == 15);
	7406	assert_or_panic(v[338] == 16);
	7407	assert_or_panic(v[339] == 17);
	7408	assert_or_panic(v[340] == 18);
	7409	assert_or_panic(v[341] == 19);
	7410	assert_or_panic(v[342] == 20);
	7411	assert_or_panic(v[343] == 21);
	7412	assert_or_panic(v[344] == 22);
	7413	assert_or_panic(v[345] == 23);
	7414	assert_or_panic(v[346] == 24);
	7415	assert_or_panic(v[347] == 25);
	7416	assert_or_panic(v[348] == 26);
	7417	assert_or_panic(v[349] == 27);
	7418	assert_or_panic(v[350] == 28);
	7419	assert_or_panic(v[351] == 29);
	7420	assert_or_panic(v[352] == 30);
	7421	assert_or_panic(v[353] == 31);
	7422	assert_or_panic(v[354] == 32);
	7423	assert_or_panic(v[355] == 33);
	7424	assert_or_panic(v[356] == 34);
	7425	assert_or_panic(v[357] == 35);
	7426	assert_or_panic(v[358] == 36);
	7427	assert_or_panic(v[359] == 37);
	7428	assert_or_panic(v[360] == 38);
	7429	assert_or_panic(v[361] == 39);
	7430	assert_or_panic(v[362] == 40);
	7431	assert_or_panic(v[363] == 41);
	7432	assert_or_panic(v[364] == 42);
	7433	assert_or_panic(v[365] == 43);
	7434	assert_or_panic(v[366] == 44);
	7435	assert_or_panic(v[367] == 45);
	7436	assert_or_panic(v[368] == 46);
	7437	assert_or_panic(v[369] == 47);
	7438	assert_or_panic(v[370] == 48);
	7439	assert_or_panic(v[371] == 49);
	7440	assert_or_panic(v[372] == 50);
	7441	assert_or_panic(v[373] == 51);
	7442	assert_or_panic(v[374] == 52);
	7443	assert_or_panic(v[375] == 53);
	7444	assert_or_panic(v[376] == 54);
	7445	assert_or_panic(v[377] == 55);
	7446	assert_or_panic(v[378] == 56);
	7447	assert_or_panic(v[379] == 57);
	7448	assert_or_panic(v[380] == 58);
	7449	assert_or_panic(v[381] == 59);
	7450	assert_or_panic(v[382] == 60);
	7451	assert_or_panic(v[383] == 61);
	7452	zig_vector_384_u8((Vector_384_u8){
	7453	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	7454	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	7455	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	7456	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	7457	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	7458	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	7459	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	7460	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	7461	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	7462	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	7463	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	7464	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	7465	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	7466	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	7467	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	7468	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	7469	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	7470	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	7471	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	7472	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	7473	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	7474	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	7475	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	7476	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	7477	}, 384);
	7478	}
	7479
	7480	typedef uint8_t Vector_512_u8 __attribute__((vector_size(512 * sizeof(uint8_t))));
	7481
	7482	Vector_512_u8 zig_ret_vector_512_u8(void);
	7483	void zig_vector_512_u8(Vector_512_u8, size_t);
	7484
	7485	Vector_512_u8 c_ret_vector_512_u8(void) {
	7486	return (Vector_512_u8){
	7487	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	7488	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	7489	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	7490	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	7491	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	7492	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	7493	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	7494	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	7495	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	7496	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	7497	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	7498	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	7499	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	7500	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	7501	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	7502	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	7503	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	7504	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	7505	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	7506	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	7507	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	7508	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	7509	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	7510	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	7511	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	7512	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	7513	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	7514	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	7515	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	7516	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	7517	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	7518	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	7519	};
	7520	}
	7521	void c_vector_512_u8(Vector_512_u8 v, size_t i) {
	7522	assert_or_panic(v[0] == 50);
	7523	assert_or_panic(v[1] == 51);
	7524	assert_or_panic(v[2] == 52);
	7525	assert_or_panic(v[3] == 53);
	7526	assert_or_panic(v[4] == 54);
	7527	assert_or_panic(v[5] == 55);
	7528	assert_or_panic(v[6] == 56);
	7529	assert_or_panic(v[7] == 57);
	7530	assert_or_panic(v[8] == 58);
	7531	assert_or_panic(v[9] == 59);
	7532	assert_or_panic(v[10] == 60);
	7533	assert_or_panic(v[11] == 61);
	7534	assert_or_panic(v[12] == 62);
	7535	assert_or_panic(v[13] == 63);
	7536	assert_or_panic(v[14] == 64);
	7537	assert_or_panic(v[15] == 65);
	7538	assert_or_panic(v[16] == 66);
	7539	assert_or_panic(v[17] == 67);
	7540	assert_or_panic(v[18] == 68);
	7541	assert_or_panic(v[19] == 69);
	7542	assert_or_panic(v[20] == 70);
	7543	assert_or_panic(v[21] == 71);
	7544	assert_or_panic(v[22] == 72);
	7545	assert_or_panic(v[23] == 73);
	7546	assert_or_panic(v[24] == 74);
	7547	assert_or_panic(v[25] == 75);
	7548	assert_or_panic(v[26] == 76);
	7549	assert_or_panic(v[27] == 77);
	7550	assert_or_panic(v[28] == 78);
	7551	assert_or_panic(v[29] == 79);
	7552	assert_or_panic(v[30] == 80);
	7553	assert_or_panic(v[31] == 81);
	7554	assert_or_panic(v[32] == 82);
	7555	assert_or_panic(v[33] == 83);
	7556	assert_or_panic(v[34] == 84);
	7557	assert_or_panic(v[35] == 85);
	7558	assert_or_panic(v[36] == 86);
	7559	assert_or_panic(v[37] == 87);
	7560	assert_or_panic(v[38] == 88);
	7561	assert_or_panic(v[39] == 89);
	7562	assert_or_panic(v[40] == 90);
	7563	assert_or_panic(v[41] == 91);
	7564	assert_or_panic(v[42] == 92);
	7565	assert_or_panic(v[43] == 93);
	7566	assert_or_panic(v[44] == 94);
	7567	assert_or_panic(v[45] == 95);
	7568	assert_or_panic(v[46] == 96);
	7569	assert_or_panic(v[47] == 97);
	7570	assert_or_panic(v[48] == 98);
	7571	assert_or_panic(v[49] == 99);
	7572	assert_or_panic(v[50] == 0);
	7573	assert_or_panic(v[51] == 1);
	7574	assert_or_panic(v[52] == 2);
	7575	assert_or_panic(v[53] == 3);
	7576	assert_or_panic(v[54] == 4);
	7577	assert_or_panic(v[55] == 5);
	7578	assert_or_panic(v[56] == 6);
	7579	assert_or_panic(v[57] == 7);
	7580	assert_or_panic(v[58] == 8);
	7581	assert_or_panic(v[59] == 9);
	7582	assert_or_panic(v[60] == 10);
	7583	assert_or_panic(v[61] == 11);
	7584	assert_or_panic(v[62] == 12);
	7585	assert_or_panic(v[63] == 13);
	7586	assert_or_panic(v[64] == 14);
	7587	assert_or_panic(v[65] == 15);
	7588	assert_or_panic(v[66] == 16);
	7589	assert_or_panic(v[67] == 17);
	7590	assert_or_panic(v[68] == 18);
	7591	assert_or_panic(v[69] == 19);
	7592	assert_or_panic(v[70] == 20);
	7593	assert_or_panic(v[71] == 21);
	7594	assert_or_panic(v[72] == 22);
	7595	assert_or_panic(v[73] == 23);
	7596	assert_or_panic(v[74] == 24);
	7597	assert_or_panic(v[75] == 25);
	7598	assert_or_panic(v[76] == 26);
	7599	assert_or_panic(v[77] == 27);
	7600	assert_or_panic(v[78] == 28);
	7601	assert_or_panic(v[79] == 29);
	7602	assert_or_panic(v[80] == 30);
	7603	assert_or_panic(v[81] == 31);
	7604	assert_or_panic(v[82] == 32);
	7605	assert_or_panic(v[83] == 33);
	7606	assert_or_panic(v[84] == 34);
	7607	assert_or_panic(v[85] == 35);
	7608	assert_or_panic(v[86] == 36);
	7609	assert_or_panic(v[87] == 37);
	7610	assert_or_panic(v[88] == 38);
	7611	assert_or_panic(v[89] == 39);
	7612	assert_or_panic(v[90] == 40);
	7613	assert_or_panic(v[91] == 41);
	7614	assert_or_panic(v[92] == 42);
	7615	assert_or_panic(v[93] == 43);
	7616	assert_or_panic(v[94] == 44);
	7617	assert_or_panic(v[95] == 45);
	7618	assert_or_panic(v[96] == 46);
	7619	assert_or_panic(v[97] == 47);
	7620	assert_or_panic(v[98] == 48);
	7621	assert_or_panic(v[99] == 49);
	7622	assert_or_panic(v[100] == 50);
	7623	assert_or_panic(v[101] == 51);
	7624	assert_or_panic(v[102] == 52);
	7625	assert_or_panic(v[103] == 53);
	7626	assert_or_panic(v[104] == 54);
	7627	assert_or_panic(v[105] == 55);
	7628	assert_or_panic(v[106] == 56);
	7629	assert_or_panic(v[107] == 57);
	7630	assert_or_panic(v[108] == 58);
	7631	assert_or_panic(v[109] == 59);
	7632	assert_or_panic(v[110] == 60);
	7633	assert_or_panic(v[111] == 61);
	7634	assert_or_panic(v[112] == 62);
	7635	assert_or_panic(v[113] == 63);
	7636	assert_or_panic(v[114] == 64);
	7637	assert_or_panic(v[115] == 65);
	7638	assert_or_panic(v[116] == 66);
	7639	assert_or_panic(v[117] == 67);
	7640	assert_or_panic(v[118] == 68);
	7641	assert_or_panic(v[119] == 69);
	7642	assert_or_panic(v[120] == 70);
	7643	assert_or_panic(v[121] == 71);
	7644	assert_or_panic(v[122] == 72);
	7645	assert_or_panic(v[123] == 73);
	7646	assert_or_panic(v[124] == 74);
	7647	assert_or_panic(v[125] == 75);
	7648	assert_or_panic(v[126] == 76);
	7649	assert_or_panic(v[127] == 77);
	7650	assert_or_panic(v[128] == 78);
	7651	assert_or_panic(v[129] == 79);
	7652	assert_or_panic(v[130] == 80);
	7653	assert_or_panic(v[131] == 81);
	7654	assert_or_panic(v[132] == 82);
	7655	assert_or_panic(v[133] == 83);
	7656	assert_or_panic(v[134] == 84);
	7657	assert_or_panic(v[135] == 85);
	7658	assert_or_panic(v[136] == 86);
	7659	assert_or_panic(v[137] == 87);
	7660	assert_or_panic(v[138] == 88);
	7661	assert_or_panic(v[139] == 89);
	7662	assert_or_panic(v[140] == 90);
	7663	assert_or_panic(v[141] == 91);
	7664	assert_or_panic(v[142] == 92);
	7665	assert_or_panic(v[143] == 93);
	7666	assert_or_panic(v[144] == 94);
	7667	assert_or_panic(v[145] == 95);
	7668	assert_or_panic(v[146] == 96);
	7669	assert_or_panic(v[147] == 97);
	7670	assert_or_panic(v[148] == 98);
	7671	assert_or_panic(v[149] == 99);
	7672	assert_or_panic(v[150] == 0);
	7673	assert_or_panic(v[151] == 1);
	7674	assert_or_panic(v[152] == 2);
	7675	assert_or_panic(v[153] == 3);
	7676	assert_or_panic(v[154] == 4);
	7677	assert_or_panic(v[155] == 5);
	7678	assert_or_panic(v[156] == 6);
	7679	assert_or_panic(v[157] == 7);
	7680	assert_or_panic(v[158] == 8);
	7681	assert_or_panic(v[159] == 9);
	7682	assert_or_panic(v[160] == 10);
	7683	assert_or_panic(v[161] == 11);
	7684	assert_or_panic(v[162] == 12);
	7685	assert_or_panic(v[163] == 13);
	7686	assert_or_panic(v[164] == 14);
	7687	assert_or_panic(v[165] == 15);
	7688	assert_or_panic(v[166] == 16);
	7689	assert_or_panic(v[167] == 17);
	7690	assert_or_panic(v[168] == 18);
	7691	assert_or_panic(v[169] == 19);
	7692	assert_or_panic(v[170] == 20);
	7693	assert_or_panic(v[171] == 21);
	7694	assert_or_panic(v[172] == 22);
	7695	assert_or_panic(v[173] == 23);
	7696	assert_or_panic(v[174] == 24);
	7697	assert_or_panic(v[175] == 25);
	7698	assert_or_panic(v[176] == 26);
	7699	assert_or_panic(v[177] == 27);
	7700	assert_or_panic(v[178] == 28);
	7701	assert_or_panic(v[179] == 29);
	7702	assert_or_panic(v[180] == 30);
	7703	assert_or_panic(v[181] == 31);
	7704	assert_or_panic(v[182] == 32);
	7705	assert_or_panic(v[183] == 33);
	7706	assert_or_panic(v[184] == 34);
	7707	assert_or_panic(v[185] == 35);
	7708	assert_or_panic(v[186] == 36);
	7709	assert_or_panic(v[187] == 37);
	7710	assert_or_panic(v[188] == 38);
	7711	assert_or_panic(v[189] == 39);
	7712	assert_or_panic(v[190] == 40);
	7713	assert_or_panic(v[191] == 41);
	7714	assert_or_panic(v[192] == 42);
	7715	assert_or_panic(v[193] == 43);
	7716	assert_or_panic(v[194] == 44);
	7717	assert_or_panic(v[195] == 45);
	7718	assert_or_panic(v[196] == 46);
	7719	assert_or_panic(v[197] == 47);
	7720	assert_or_panic(v[198] == 48);
	7721	assert_or_panic(v[199] == 49);
	7722	assert_or_panic(v[200] == 50);
	7723	assert_or_panic(v[201] == 51);
	7724	assert_or_panic(v[202] == 52);
	7725	assert_or_panic(v[203] == 53);
	7726	assert_or_panic(v[204] == 54);
	7727	assert_or_panic(v[205] == 55);
	7728	assert_or_panic(v[206] == 56);
	7729	assert_or_panic(v[207] == 57);
	7730	assert_or_panic(v[208] == 58);
	7731	assert_or_panic(v[209] == 59);
	7732	assert_or_panic(v[210] == 60);
	7733	assert_or_panic(v[211] == 61);
	7734	assert_or_panic(v[212] == 62);
	7735	assert_or_panic(v[213] == 63);
	7736	assert_or_panic(v[214] == 64);
	7737	assert_or_panic(v[215] == 65);
	7738	assert_or_panic(v[216] == 66);
	7739	assert_or_panic(v[217] == 67);
	7740	assert_or_panic(v[218] == 68);
	7741	assert_or_panic(v[219] == 69);
	7742	assert_or_panic(v[220] == 70);
	7743	assert_or_panic(v[221] == 71);
	7744	assert_or_panic(v[222] == 72);
	7745	assert_or_panic(v[223] == 73);
	7746	assert_or_panic(v[224] == 74);
	7747	assert_or_panic(v[225] == 75);
	7748	assert_or_panic(v[226] == 76);
	7749	assert_or_panic(v[227] == 77);
	7750	assert_or_panic(v[228] == 78);
	7751	assert_or_panic(v[229] == 79);
	7752	assert_or_panic(v[230] == 80);
	7753	assert_or_panic(v[231] == 81);
	7754	assert_or_panic(v[232] == 82);
	7755	assert_or_panic(v[233] == 83);
	7756	assert_or_panic(v[234] == 84);
	7757	assert_or_panic(v[235] == 85);
	7758	assert_or_panic(v[236] == 86);
	7759	assert_or_panic(v[237] == 87);
	7760	assert_or_panic(v[238] == 88);
	7761	assert_or_panic(v[239] == 89);
	7762	assert_or_panic(v[240] == 90);
	7763	assert_or_panic(v[241] == 91);
	7764	assert_or_panic(v[242] == 92);
	7765	assert_or_panic(v[243] == 93);
	7766	assert_or_panic(v[244] == 94);
	7767	assert_or_panic(v[245] == 95);
	7768	assert_or_panic(v[246] == 96);
	7769	assert_or_panic(v[247] == 97);
	7770	assert_or_panic(v[248] == 98);
	7771	assert_or_panic(v[249] == 99);
	7772	assert_or_panic(v[250] == 0);
	7773	assert_or_panic(v[251] == 1);
	7774	assert_or_panic(v[252] == 2);
	7775	assert_or_panic(v[253] == 3);
	7776	assert_or_panic(v[254] == 4);
	7777	assert_or_panic(v[255] == 5);
	7778	assert_or_panic(v[256] == 6);
	7779	assert_or_panic(v[257] == 7);
	7780	assert_or_panic(v[258] == 8);
	7781	assert_or_panic(v[259] == 9);
	7782	assert_or_panic(v[260] == 10);
	7783	assert_or_panic(v[261] == 11);
	7784	assert_or_panic(v[262] == 12);
	7785	assert_or_panic(v[263] == 13);
	7786	assert_or_panic(v[264] == 14);
	7787	assert_or_panic(v[265] == 15);
	7788	assert_or_panic(v[266] == 16);
	7789	assert_or_panic(v[267] == 17);
	7790	assert_or_panic(v[268] == 18);
	7791	assert_or_panic(v[269] == 19);
	7792	assert_or_panic(v[270] == 20);
	7793	assert_or_panic(v[271] == 21);
	7794	assert_or_panic(v[272] == 22);
	7795	assert_or_panic(v[273] == 23);
	7796	assert_or_panic(v[274] == 24);
	7797	assert_or_panic(v[275] == 25);
	7798	assert_or_panic(v[276] == 26);
	7799	assert_or_panic(v[277] == 27);
	7800	assert_or_panic(v[278] == 28);
	7801	assert_or_panic(v[279] == 29);
	7802	assert_or_panic(v[280] == 30);
	7803	assert_or_panic(v[281] == 31);
	7804	assert_or_panic(v[282] == 32);
	7805	assert_or_panic(v[283] == 33);
	7806	assert_or_panic(v[284] == 34);
	7807	assert_or_panic(v[285] == 35);
	7808	assert_or_panic(v[286] == 36);
	7809	assert_or_panic(v[287] == 37);
	7810	assert_or_panic(v[288] == 38);
	7811	assert_or_panic(v[289] == 39);
	7812	assert_or_panic(v[290] == 40);
	7813	assert_or_panic(v[291] == 41);
	7814	assert_or_panic(v[292] == 42);
	7815	assert_or_panic(v[293] == 43);
	7816	assert_or_panic(v[294] == 44);
	7817	assert_or_panic(v[295] == 45);
	7818	assert_or_panic(v[296] == 46);
	7819	assert_or_panic(v[297] == 47);
	7820	assert_or_panic(v[298] == 48);
	7821	assert_or_panic(v[299] == 49);
	7822	assert_or_panic(v[300] == 50);
	7823	assert_or_panic(v[301] == 51);
	7824	assert_or_panic(v[302] == 52);
	7825	assert_or_panic(v[303] == 53);
	7826	assert_or_panic(v[304] == 54);
	7827	assert_or_panic(v[305] == 55);
	7828	assert_or_panic(v[306] == 56);
	7829	assert_or_panic(v[307] == 57);
	7830	assert_or_panic(v[308] == 58);
	7831	assert_or_panic(v[309] == 59);
	7832	assert_or_panic(v[310] == 60);
	7833	assert_or_panic(v[311] == 61);
	7834	assert_or_panic(v[312] == 62);
	7835	assert_or_panic(v[313] == 63);
	7836	assert_or_panic(v[314] == 64);
	7837	assert_or_panic(v[315] == 65);
	7838	assert_or_panic(v[316] == 66);
	7839	assert_or_panic(v[317] == 67);
	7840	assert_or_panic(v[318] == 68);
	7841	assert_or_panic(v[319] == 69);
	7842	assert_or_panic(v[320] == 70);
	7843	assert_or_panic(v[321] == 71);
	7844	assert_or_panic(v[322] == 72);
	7845	assert_or_panic(v[323] == 73);
	7846	assert_or_panic(v[324] == 74);
	7847	assert_or_panic(v[325] == 75);
	7848	assert_or_panic(v[326] == 76);
	7849	assert_or_panic(v[327] == 77);
	7850	assert_or_panic(v[328] == 78);
	7851	assert_or_panic(v[329] == 79);
	7852	assert_or_panic(v[330] == 80);
	7853	assert_or_panic(v[331] == 81);
	7854	assert_or_panic(v[332] == 82);
	7855	assert_or_panic(v[333] == 83);
	7856	assert_or_panic(v[334] == 84);
	7857	assert_or_panic(v[335] == 85);
	7858	assert_or_panic(v[336] == 86);
	7859	assert_or_panic(v[337] == 87);
	7860	assert_or_panic(v[338] == 88);
	7861	assert_or_panic(v[339] == 89);
	7862	assert_or_panic(v[340] == 90);
	7863	assert_or_panic(v[341] == 91);
	7864	assert_or_panic(v[342] == 92);
	7865	assert_or_panic(v[343] == 93);
	7866	assert_or_panic(v[344] == 94);
	7867	assert_or_panic(v[345] == 95);
	7868	assert_or_panic(v[346] == 96);
	7869	assert_or_panic(v[347] == 97);
	7870	assert_or_panic(v[348] == 98);
	7871	assert_or_panic(v[349] == 99);
	7872	assert_or_panic(v[350] == 0);
	7873	assert_or_panic(v[351] == 1);
	7874	assert_or_panic(v[352] == 2);
	7875	assert_or_panic(v[353] == 3);
	7876	assert_or_panic(v[354] == 4);
	7877	assert_or_panic(v[355] == 5);
	7878	assert_or_panic(v[356] == 6);
	7879	assert_or_panic(v[357] == 7);
	7880	assert_or_panic(v[358] == 8);
	7881	assert_or_panic(v[359] == 9);
	7882	assert_or_panic(v[360] == 10);
	7883	assert_or_panic(v[361] == 11);
	7884	assert_or_panic(v[362] == 12);
	7885	assert_or_panic(v[363] == 13);
	7886	assert_or_panic(v[364] == 14);
	7887	assert_or_panic(v[365] == 15);
	7888	assert_or_panic(v[366] == 16);
	7889	assert_or_panic(v[367] == 17);
	7890	assert_or_panic(v[368] == 18);
	7891	assert_or_panic(v[369] == 19);
	7892	assert_or_panic(v[370] == 20);
	7893	assert_or_panic(v[371] == 21);
	7894	assert_or_panic(v[372] == 22);
	7895	assert_or_panic(v[373] == 23);
	7896	assert_or_panic(v[374] == 24);
	7897	assert_or_panic(v[375] == 25);
	7898	assert_or_panic(v[376] == 26);
	7899	assert_or_panic(v[377] == 27);
	7900	assert_or_panic(v[378] == 28);
	7901	assert_or_panic(v[379] == 29);
	7902	assert_or_panic(v[380] == 30);
	7903	assert_or_panic(v[381] == 31);
	7904	assert_or_panic(v[382] == 32);
	7905	assert_or_panic(v[383] == 33);
	7906	assert_or_panic(v[384] == 34);
	7907	assert_or_panic(v[385] == 35);
	7908	assert_or_panic(v[386] == 36);
	7909	assert_or_panic(v[387] == 37);
	7910	assert_or_panic(v[388] == 38);
	7911	assert_or_panic(v[389] == 39);
	7912	assert_or_panic(v[390] == 40);
	7913	assert_or_panic(v[391] == 41);
	7914	assert_or_panic(v[392] == 42);
	7915	assert_or_panic(v[393] == 43);
	7916	assert_or_panic(v[394] == 44);
	7917	assert_or_panic(v[395] == 45);
	7918	assert_or_panic(v[396] == 46);
	7919	assert_or_panic(v[397] == 47);
	7920	assert_or_panic(v[398] == 48);
	7921	assert_or_panic(v[399] == 49);
	7922	assert_or_panic(v[400] == 50);
	7923	assert_or_panic(v[401] == 51);
	7924	assert_or_panic(v[402] == 52);
	7925	assert_or_panic(v[403] == 53);
	7926	assert_or_panic(v[404] == 54);
	7927	assert_or_panic(v[405] == 55);
	7928	assert_or_panic(v[406] == 56);
	7929	assert_or_panic(v[407] == 57);
	7930	assert_or_panic(v[408] == 58);
	7931	assert_or_panic(v[409] == 59);
	7932	assert_or_panic(v[410] == 60);
	7933	assert_or_panic(v[411] == 61);
	7934	assert_or_panic(v[412] == 62);
	7935	assert_or_panic(v[413] == 63);
	7936	assert_or_panic(v[414] == 64);
	7937	assert_or_panic(v[415] == 65);
	7938	assert_or_panic(v[416] == 66);
	7939	assert_or_panic(v[417] == 67);
	7940	assert_or_panic(v[418] == 68);
	7941	assert_or_panic(v[419] == 69);
	7942	assert_or_panic(v[420] == 70);
	7943	assert_or_panic(v[421] == 71);
	7944	assert_or_panic(v[422] == 72);
	7945	assert_or_panic(v[423] == 73);
	7946	assert_or_panic(v[424] == 74);
	7947	assert_or_panic(v[425] == 75);
	7948	assert_or_panic(v[426] == 76);
	7949	assert_or_panic(v[427] == 77);
	7950	assert_or_panic(v[428] == 78);
	7951	assert_or_panic(v[429] == 79);
	7952	assert_or_panic(v[430] == 80);
	7953	assert_or_panic(v[431] == 81);
	7954	assert_or_panic(v[432] == 82);
	7955	assert_or_panic(v[433] == 83);
	7956	assert_or_panic(v[434] == 84);
	7957	assert_or_panic(v[435] == 85);
	7958	assert_or_panic(v[436] == 86);
	7959	assert_or_panic(v[437] == 87);
	7960	assert_or_panic(v[438] == 88);
	7961	assert_or_panic(v[439] == 89);
	7962	assert_or_panic(v[440] == 90);
	7963	assert_or_panic(v[441] == 91);
	7964	assert_or_panic(v[442] == 92);
	7965	assert_or_panic(v[443] == 93);
	7966	assert_or_panic(v[444] == 94);
	7967	assert_or_panic(v[445] == 95);
	7968	assert_or_panic(v[446] == 96);
	7969	assert_or_panic(v[447] == 97);
	7970	assert_or_panic(v[448] == 98);
	7971	assert_or_panic(v[449] == 99);
	7972	assert_or_panic(v[450] == 0);
	7973	assert_or_panic(v[451] == 1);
	7974	assert_or_panic(v[452] == 2);
	7975	assert_or_panic(v[453] == 3);
	7976	assert_or_panic(v[454] == 4);
	7977	assert_or_panic(v[455] == 5);
	7978	assert_or_panic(v[456] == 6);
	7979	assert_or_panic(v[457] == 7);
	7980	assert_or_panic(v[458] == 8);
	7981	assert_or_panic(v[459] == 9);
	7982	assert_or_panic(v[460] == 10);
	7983	assert_or_panic(v[461] == 11);
	7984	assert_or_panic(v[462] == 12);
	7985	assert_or_panic(v[463] == 13);
	7986	assert_or_panic(v[464] == 14);
	7987	assert_or_panic(v[465] == 15);
	7988	assert_or_panic(v[466] == 16);
	7989	assert_or_panic(v[467] == 17);
	7990	assert_or_panic(v[468] == 18);
	7991	assert_or_panic(v[469] == 19);
	7992	assert_or_panic(v[470] == 20);
	7993	assert_or_panic(v[471] == 21);
	7994	assert_or_panic(v[472] == 22);
	7995	assert_or_panic(v[473] == 23);
	7996	assert_or_panic(v[474] == 24);
	7997	assert_or_panic(v[475] == 25);
	7998	assert_or_panic(v[476] == 26);
	7999	assert_or_panic(v[477] == 27);
	8000	assert_or_panic(v[478] == 28);
	8001	assert_or_panic(v[479] == 29);
	8002	assert_or_panic(v[480] == 30);
	8003	assert_or_panic(v[481] == 31);
	8004	assert_or_panic(v[482] == 32);
	8005	assert_or_panic(v[483] == 33);
	8006	assert_or_panic(v[484] == 34);
	8007	assert_or_panic(v[485] == 35);
	8008	assert_or_panic(v[486] == 36);
	8009	assert_or_panic(v[487] == 37);
	8010	assert_or_panic(v[488] == 38);
	8011	assert_or_panic(v[489] == 39);
	8012	assert_or_panic(v[490] == 40);
	8013	assert_or_panic(v[491] == 41);
	8014	assert_or_panic(v[492] == 42);
	8015	assert_or_panic(v[493] == 43);
	8016	assert_or_panic(v[494] == 44);
	8017	assert_or_panic(v[495] == 45);
	8018	assert_or_panic(v[496] == 46);
	8019	assert_or_panic(v[497] == 47);
	8020	assert_or_panic(v[498] == 48);
	8021	assert_or_panic(v[499] == 49);
	8022	assert_or_panic(v[500] == 50);
	8023	assert_or_panic(v[501] == 51);
	8024	assert_or_panic(v[502] == 52);
	8025	assert_or_panic(v[503] == 53);
	8026	assert_or_panic(v[504] == 54);
	8027	assert_or_panic(v[505] == 55);
	8028	assert_or_panic(v[506] == 56);
	8029	assert_or_panic(v[507] == 57);
	8030	assert_or_panic(v[508] == 58);
	8031	assert_or_panic(v[509] == 59);
	8032	assert_or_panic(v[510] == 60);
	8033	assert_or_panic(v[511] == 61);
	8034	assert_or_panic(i == 512);
	8035	}
	8036	void c_test_vector_512_u8(void) {
	8037	Vector_512_u8 v = zig_ret_vector_512_u8();
	8038	assert_or_panic(v[0] == 14);
	8039	assert_or_panic(v[1] == 15);
	8040	assert_or_panic(v[2] == 16);
	8041	assert_or_panic(v[3] == 17);
	8042	assert_or_panic(v[4] == 18);
	8043	assert_or_panic(v[5] == 19);
	8044	assert_or_panic(v[6] == 20);
	8045	assert_or_panic(v[7] == 21);
	8046	assert_or_panic(v[8] == 22);
	8047	assert_or_panic(v[9] == 23);
	8048	assert_or_panic(v[10] == 24);
	8049	assert_or_panic(v[11] == 25);
	8050	assert_or_panic(v[12] == 26);
	8051	assert_or_panic(v[13] == 27);
	8052	assert_or_panic(v[14] == 28);
	8053	assert_or_panic(v[15] == 29);
	8054	assert_or_panic(v[16] == 30);
	8055	assert_or_panic(v[17] == 31);
	8056	assert_or_panic(v[18] == 32);
	8057	assert_or_panic(v[19] == 33);
	8058	assert_or_panic(v[20] == 34);
	8059	assert_or_panic(v[21] == 35);
	8060	assert_or_panic(v[22] == 36);
	8061	assert_or_panic(v[23] == 37);
	8062	assert_or_panic(v[24] == 38);
	8063	assert_or_panic(v[25] == 39);
	8064	assert_or_panic(v[26] == 40);
	8065	assert_or_panic(v[27] == 41);
	8066	assert_or_panic(v[28] == 42);
	8067	assert_or_panic(v[29] == 43);
	8068	assert_or_panic(v[30] == 44);
	8069	assert_or_panic(v[31] == 45);
	8070	assert_or_panic(v[32] == 46);
	8071	assert_or_panic(v[33] == 47);
	8072	assert_or_panic(v[34] == 48);
	8073	assert_or_panic(v[35] == 49);
	8074	assert_or_panic(v[36] == 50);
	8075	assert_or_panic(v[37] == 51);
	8076	assert_or_panic(v[38] == 52);
	8077	assert_or_panic(v[39] == 53);
	8078	assert_or_panic(v[40] == 54);
	8079	assert_or_panic(v[41] == 55);
	8080	assert_or_panic(v[42] == 56);
	8081	assert_or_panic(v[43] == 57);
	8082	assert_or_panic(v[44] == 58);
	8083	assert_or_panic(v[45] == 59);
	8084	assert_or_panic(v[46] == 60);
	8085	assert_or_panic(v[47] == 61);
	8086	assert_or_panic(v[48] == 62);
	8087	assert_or_panic(v[49] == 63);
	8088	assert_or_panic(v[50] == 64);
	8089	assert_or_panic(v[51] == 65);
	8090	assert_or_panic(v[52] == 66);
	8091	assert_or_panic(v[53] == 67);
	8092	assert_or_panic(v[54] == 68);
	8093	assert_or_panic(v[55] == 69);
	8094	assert_or_panic(v[56] == 70);
	8095	assert_or_panic(v[57] == 71);
	8096	assert_or_panic(v[58] == 72);
	8097	assert_or_panic(v[59] == 73);
	8098	assert_or_panic(v[60] == 74);
	8099	assert_or_panic(v[61] == 75);
	8100	assert_or_panic(v[62] == 76);
	8101	assert_or_panic(v[63] == 77);
	8102	assert_or_panic(v[64] == 78);
	8103	assert_or_panic(v[65] == 79);
	8104	assert_or_panic(v[66] == 80);
	8105	assert_or_panic(v[67] == 81);
	8106	assert_or_panic(v[68] == 82);
	8107	assert_or_panic(v[69] == 83);
	8108	assert_or_panic(v[70] == 84);
	8109	assert_or_panic(v[71] == 85);
	8110	assert_or_panic(v[72] == 86);
	8111	assert_or_panic(v[73] == 87);
	8112	assert_or_panic(v[74] == 88);
	8113	assert_or_panic(v[75] == 89);
	8114	assert_or_panic(v[76] == 90);
	8115	assert_or_panic(v[77] == 91);
	8116	assert_or_panic(v[78] == 92);
	8117	assert_or_panic(v[79] == 93);
	8118	assert_or_panic(v[80] == 94);
	8119	assert_or_panic(v[81] == 95);
	8120	assert_or_panic(v[82] == 96);
	8121	assert_or_panic(v[83] == 97);
	8122	assert_or_panic(v[84] == 98);
	8123	assert_or_panic(v[85] == 99);
	8124	assert_or_panic(v[86] == 0);
	8125	assert_or_panic(v[87] == 1);
	8126	assert_or_panic(v[88] == 2);
	8127	assert_or_panic(v[89] == 3);
	8128	assert_or_panic(v[90] == 4);
	8129	assert_or_panic(v[91] == 5);
	8130	assert_or_panic(v[92] == 6);
	8131	assert_or_panic(v[93] == 7);
	8132	assert_or_panic(v[94] == 8);
	8133	assert_or_panic(v[95] == 9);
	8134	assert_or_panic(v[96] == 10);
	8135	assert_or_panic(v[97] == 11);
	8136	assert_or_panic(v[98] == 12);
	8137	assert_or_panic(v[99] == 13);
	8138	assert_or_panic(v[100] == 14);
	8139	assert_or_panic(v[101] == 15);
	8140	assert_or_panic(v[102] == 16);
	8141	assert_or_panic(v[103] == 17);
	8142	assert_or_panic(v[104] == 18);
	8143	assert_or_panic(v[105] == 19);
	8144	assert_or_panic(v[106] == 20);
	8145	assert_or_panic(v[107] == 21);
	8146	assert_or_panic(v[108] == 22);
	8147	assert_or_panic(v[109] == 23);
	8148	assert_or_panic(v[110] == 24);
	8149	assert_or_panic(v[111] == 25);
	8150	assert_or_panic(v[112] == 26);
	8151	assert_or_panic(v[113] == 27);
	8152	assert_or_panic(v[114] == 28);
	8153	assert_or_panic(v[115] == 29);
	8154	assert_or_panic(v[116] == 30);
	8155	assert_or_panic(v[117] == 31);
	8156	assert_or_panic(v[118] == 32);
	8157	assert_or_panic(v[119] == 33);
	8158	assert_or_panic(v[120] == 34);
	8159	assert_or_panic(v[121] == 35);
	8160	assert_or_panic(v[122] == 36);
	8161	assert_or_panic(v[123] == 37);
	8162	assert_or_panic(v[124] == 38);
	8163	assert_or_panic(v[125] == 39);
	8164	assert_or_panic(v[126] == 40);
	8165	assert_or_panic(v[127] == 41);
	8166	assert_or_panic(v[128] == 42);
	8167	assert_or_panic(v[129] == 43);
	8168	assert_or_panic(v[130] == 44);
	8169	assert_or_panic(v[131] == 45);
	8170	assert_or_panic(v[132] == 46);
	8171	assert_or_panic(v[133] == 47);
	8172	assert_or_panic(v[134] == 48);
	8173	assert_or_panic(v[135] == 49);
	8174	assert_or_panic(v[136] == 50);
	8175	assert_or_panic(v[137] == 51);
	8176	assert_or_panic(v[138] == 52);
	8177	assert_or_panic(v[139] == 53);
	8178	assert_or_panic(v[140] == 54);
	8179	assert_or_panic(v[141] == 55);
	8180	assert_or_panic(v[142] == 56);
	8181	assert_or_panic(v[143] == 57);
	8182	assert_or_panic(v[144] == 58);
	8183	assert_or_panic(v[145] == 59);
	8184	assert_or_panic(v[146] == 60);
	8185	assert_or_panic(v[147] == 61);
	8186	assert_or_panic(v[148] == 62);
	8187	assert_or_panic(v[149] == 63);
	8188	assert_or_panic(v[150] == 64);
	8189	assert_or_panic(v[151] == 65);
	8190	assert_or_panic(v[152] == 66);
	8191	assert_or_panic(v[153] == 67);
	8192	assert_or_panic(v[154] == 68);
	8193	assert_or_panic(v[155] == 69);
	8194	assert_or_panic(v[156] == 70);
	8195	assert_or_panic(v[157] == 71);
	8196	assert_or_panic(v[158] == 72);
	8197	assert_or_panic(v[159] == 73);
	8198	assert_or_panic(v[160] == 74);
	8199	assert_or_panic(v[161] == 75);
	8200	assert_or_panic(v[162] == 76);
	8201	assert_or_panic(v[163] == 77);
	8202	assert_or_panic(v[164] == 78);
	8203	assert_or_panic(v[165] == 79);
	8204	assert_or_panic(v[166] == 80);
	8205	assert_or_panic(v[167] == 81);
	8206	assert_or_panic(v[168] == 82);
	8207	assert_or_panic(v[169] == 83);
	8208	assert_or_panic(v[170] == 84);
	8209	assert_or_panic(v[171] == 85);
	8210	assert_or_panic(v[172] == 86);
	8211	assert_or_panic(v[173] == 87);
	8212	assert_or_panic(v[174] == 88);
	8213	assert_or_panic(v[175] == 89);
	8214	assert_or_panic(v[176] == 90);
	8215	assert_or_panic(v[177] == 91);
	8216	assert_or_panic(v[178] == 92);
	8217	assert_or_panic(v[179] == 93);
	8218	assert_or_panic(v[180] == 94);
	8219	assert_or_panic(v[181] == 95);
	8220	assert_or_panic(v[182] == 96);
	8221	assert_or_panic(v[183] == 97);
	8222	assert_or_panic(v[184] == 98);
	8223	assert_or_panic(v[185] == 99);
	8224	assert_or_panic(v[186] == 0);
	8225	assert_or_panic(v[187] == 1);
	8226	assert_or_panic(v[188] == 2);
	8227	assert_or_panic(v[189] == 3);
	8228	assert_or_panic(v[190] == 4);
	8229	assert_or_panic(v[191] == 5);
	8230	assert_or_panic(v[192] == 6);
	8231	assert_or_panic(v[193] == 7);
	8232	assert_or_panic(v[194] == 8);
	8233	assert_or_panic(v[195] == 9);
	8234	assert_or_panic(v[196] == 10);
	8235	assert_or_panic(v[197] == 11);
	8236	assert_or_panic(v[198] == 12);
	8237	assert_or_panic(v[199] == 13);
	8238	assert_or_panic(v[200] == 14);
	8239	assert_or_panic(v[201] == 15);
	8240	assert_or_panic(v[202] == 16);
	8241	assert_or_panic(v[203] == 17);
	8242	assert_or_panic(v[204] == 18);
	8243	assert_or_panic(v[205] == 19);
	8244	assert_or_panic(v[206] == 20);
	8245	assert_or_panic(v[207] == 21);
	8246	assert_or_panic(v[208] == 22);
	8247	assert_or_panic(v[209] == 23);
	8248	assert_or_panic(v[210] == 24);
	8249	assert_or_panic(v[211] == 25);
	8250	assert_or_panic(v[212] == 26);
	8251	assert_or_panic(v[213] == 27);
	8252	assert_or_panic(v[214] == 28);
	8253	assert_or_panic(v[215] == 29);
	8254	assert_or_panic(v[216] == 30);
	8255	assert_or_panic(v[217] == 31);
	8256	assert_or_panic(v[218] == 32);
	8257	assert_or_panic(v[219] == 33);
	8258	assert_or_panic(v[220] == 34);
	8259	assert_or_panic(v[221] == 35);
	8260	assert_or_panic(v[222] == 36);
	8261	assert_or_panic(v[223] == 37);
	8262	assert_or_panic(v[224] == 38);
	8263	assert_or_panic(v[225] == 39);
	8264	assert_or_panic(v[226] == 40);
	8265	assert_or_panic(v[227] == 41);
	8266	assert_or_panic(v[228] == 42);
	8267	assert_or_panic(v[229] == 43);
	8268	assert_or_panic(v[230] == 44);
	8269	assert_or_panic(v[231] == 45);
	8270	assert_or_panic(v[232] == 46);
	8271	assert_or_panic(v[233] == 47);
	8272	assert_or_panic(v[234] == 48);
	8273	assert_or_panic(v[235] == 49);
	8274	assert_or_panic(v[236] == 50);
	8275	assert_or_panic(v[237] == 51);
	8276	assert_or_panic(v[238] == 52);
	8277	assert_or_panic(v[239] == 53);
	8278	assert_or_panic(v[240] == 54);
	8279	assert_or_panic(v[241] == 55);
	8280	assert_or_panic(v[242] == 56);
	8281	assert_or_panic(v[243] == 57);
	8282	assert_or_panic(v[244] == 58);
	8283	assert_or_panic(v[245] == 59);
	8284	assert_or_panic(v[246] == 60);
	8285	assert_or_panic(v[247] == 61);
	8286	assert_or_panic(v[248] == 62);
	8287	assert_or_panic(v[249] == 63);
	8288	assert_or_panic(v[250] == 64);
	8289	assert_or_panic(v[251] == 65);
	8290	assert_or_panic(v[252] == 66);
	8291	assert_or_panic(v[253] == 67);
	8292	assert_or_panic(v[254] == 68);
	8293	assert_or_panic(v[255] == 69);
	8294	assert_or_panic(v[256] == 70);
	8295	assert_or_panic(v[257] == 71);
	8296	assert_or_panic(v[258] == 72);
	8297	assert_or_panic(v[259] == 73);
	8298	assert_or_panic(v[260] == 74);
	8299	assert_or_panic(v[261] == 75);
	8300	assert_or_panic(v[262] == 76);
	8301	assert_or_panic(v[263] == 77);
	8302	assert_or_panic(v[264] == 78);
	8303	assert_or_panic(v[265] == 79);
	8304	assert_or_panic(v[266] == 80);
	8305	assert_or_panic(v[267] == 81);
	8306	assert_or_panic(v[268] == 82);
	8307	assert_or_panic(v[269] == 83);
	8308	assert_or_panic(v[270] == 84);
	8309	assert_or_panic(v[271] == 85);
	8310	assert_or_panic(v[272] == 86);
	8311	assert_or_panic(v[273] == 87);
	8312	assert_or_panic(v[274] == 88);
	8313	assert_or_panic(v[275] == 89);
	8314	assert_or_panic(v[276] == 90);
	8315	assert_or_panic(v[277] == 91);
	8316	assert_or_panic(v[278] == 92);
	8317	assert_or_panic(v[279] == 93);
	8318	assert_or_panic(v[280] == 94);
	8319	assert_or_panic(v[281] == 95);
	8320	assert_or_panic(v[282] == 96);
	8321	assert_or_panic(v[283] == 97);
	8322	assert_or_panic(v[284] == 98);
	8323	assert_or_panic(v[285] == 99);
	8324	assert_or_panic(v[286] == 0);
	8325	assert_or_panic(v[287] == 1);
	8326	assert_or_panic(v[288] == 2);
	8327	assert_or_panic(v[289] == 3);
	8328	assert_or_panic(v[290] == 4);
	8329	assert_or_panic(v[291] == 5);
	8330	assert_or_panic(v[292] == 6);
	8331	assert_or_panic(v[293] == 7);
	8332	assert_or_panic(v[294] == 8);
	8333	assert_or_panic(v[295] == 9);
	8334	assert_or_panic(v[296] == 10);
	8335	assert_or_panic(v[297] == 11);
	8336	assert_or_panic(v[298] == 12);
	8337	assert_or_panic(v[299] == 13);
	8338	assert_or_panic(v[300] == 14);
	8339	assert_or_panic(v[301] == 15);
	8340	assert_or_panic(v[302] == 16);
	8341	assert_or_panic(v[303] == 17);
	8342	assert_or_panic(v[304] == 18);
	8343	assert_or_panic(v[305] == 19);
	8344	assert_or_panic(v[306] == 20);
	8345	assert_or_panic(v[307] == 21);
	8346	assert_or_panic(v[308] == 22);
	8347	assert_or_panic(v[309] == 23);
	8348	assert_or_panic(v[310] == 24);
	8349	assert_or_panic(v[311] == 25);
	8350	assert_or_panic(v[312] == 26);
	8351	assert_or_panic(v[313] == 27);
	8352	assert_or_panic(v[314] == 28);
	8353	assert_or_panic(v[315] == 29);
	8354	assert_or_panic(v[316] == 30);
	8355	assert_or_panic(v[317] == 31);
	8356	assert_or_panic(v[318] == 32);
	8357	assert_or_panic(v[319] == 33);
	8358	assert_or_panic(v[320] == 34);
	8359	assert_or_panic(v[321] == 35);
	8360	assert_or_panic(v[322] == 36);
	8361	assert_or_panic(v[323] == 37);
	8362	assert_or_panic(v[324] == 38);
	8363	assert_or_panic(v[325] == 39);
	8364	assert_or_panic(v[326] == 40);
	8365	assert_or_panic(v[327] == 41);
	8366	assert_or_panic(v[328] == 42);
	8367	assert_or_panic(v[329] == 43);
	8368	assert_or_panic(v[330] == 44);
	8369	assert_or_panic(v[331] == 45);
	8370	assert_or_panic(v[332] == 46);
	8371	assert_or_panic(v[333] == 47);
	8372	assert_or_panic(v[334] == 48);
	8373	assert_or_panic(v[335] == 49);
	8374	assert_or_panic(v[336] == 50);
	8375	assert_or_panic(v[337] == 51);
	8376	assert_or_panic(v[338] == 52);
	8377	assert_or_panic(v[339] == 53);
	8378	assert_or_panic(v[340] == 54);
	8379	assert_or_panic(v[341] == 55);
	8380	assert_or_panic(v[342] == 56);
	8381	assert_or_panic(v[343] == 57);
	8382	assert_or_panic(v[344] == 58);
	8383	assert_or_panic(v[345] == 59);
	8384	assert_or_panic(v[346] == 60);
	8385	assert_or_panic(v[347] == 61);
	8386	assert_or_panic(v[348] == 62);
	8387	assert_or_panic(v[349] == 63);
	8388	assert_or_panic(v[350] == 64);
	8389	assert_or_panic(v[351] == 65);
	8390	assert_or_panic(v[352] == 66);
	8391	assert_or_panic(v[353] == 67);
	8392	assert_or_panic(v[354] == 68);
	8393	assert_or_panic(v[355] == 69);
	8394	assert_or_panic(v[356] == 70);
	8395	assert_or_panic(v[357] == 71);
	8396	assert_or_panic(v[358] == 72);
	8397	assert_or_panic(v[359] == 73);
	8398	assert_or_panic(v[360] == 74);
	8399	assert_or_panic(v[361] == 75);
	8400	assert_or_panic(v[362] == 76);
	8401	assert_or_panic(v[363] == 77);
	8402	assert_or_panic(v[364] == 78);
	8403	assert_or_panic(v[365] == 79);
	8404	assert_or_panic(v[366] == 80);
	8405	assert_or_panic(v[367] == 81);
	8406	assert_or_panic(v[368] == 82);
	8407	assert_or_panic(v[369] == 83);
	8408	assert_or_panic(v[370] == 84);
	8409	assert_or_panic(v[371] == 85);
	8410	assert_or_panic(v[372] == 86);
	8411	assert_or_panic(v[373] == 87);
	8412	assert_or_panic(v[374] == 88);
	8413	assert_or_panic(v[375] == 89);
	8414	assert_or_panic(v[376] == 90);
	8415	assert_or_panic(v[377] == 91);
	8416	assert_or_panic(v[378] == 92);
	8417	assert_or_panic(v[379] == 93);
	8418	assert_or_panic(v[380] == 94);
	8419	assert_or_panic(v[381] == 95);
	8420	assert_or_panic(v[382] == 96);
	8421	assert_or_panic(v[383] == 97);
	8422	assert_or_panic(v[384] == 98);
	8423	assert_or_panic(v[385] == 99);
	8424	assert_or_panic(v[386] == 0);
	8425	assert_or_panic(v[387] == 1);
	8426	assert_or_panic(v[388] == 2);
	8427	assert_or_panic(v[389] == 3);
	8428	assert_or_panic(v[390] == 4);
	8429	assert_or_panic(v[391] == 5);
	8430	assert_or_panic(v[392] == 6);
	8431	assert_or_panic(v[393] == 7);
	8432	assert_or_panic(v[394] == 8);
	8433	assert_or_panic(v[395] == 9);
	8434	assert_or_panic(v[396] == 10);
	8435	assert_or_panic(v[397] == 11);
	8436	assert_or_panic(v[398] == 12);
	8437	assert_or_panic(v[399] == 13);
	8438	assert_or_panic(v[400] == 14);
	8439	assert_or_panic(v[401] == 15);
	8440	assert_or_panic(v[402] == 16);
	8441	assert_or_panic(v[403] == 17);
	8442	assert_or_panic(v[404] == 18);
	8443	assert_or_panic(v[405] == 19);
	8444	assert_or_panic(v[406] == 20);
	8445	assert_or_panic(v[407] == 21);
	8446	assert_or_panic(v[408] == 22);
	8447	assert_or_panic(v[409] == 23);
	8448	assert_or_panic(v[410] == 24);
	8449	assert_or_panic(v[411] == 25);
	8450	assert_or_panic(v[412] == 26);
	8451	assert_or_panic(v[413] == 27);
	8452	assert_or_panic(v[414] == 28);
	8453	assert_or_panic(v[415] == 29);
	8454	assert_or_panic(v[416] == 30);
	8455	assert_or_panic(v[417] == 31);
	8456	assert_or_panic(v[418] == 32);
	8457	assert_or_panic(v[419] == 33);
	8458	assert_or_panic(v[420] == 34);
	8459	assert_or_panic(v[421] == 35);
	8460	assert_or_panic(v[422] == 36);
	8461	assert_or_panic(v[423] == 37);
	8462	assert_or_panic(v[424] == 38);
	8463	assert_or_panic(v[425] == 39);
	8464	assert_or_panic(v[426] == 40);
	8465	assert_or_panic(v[427] == 41);
	8466	assert_or_panic(v[428] == 42);
	8467	assert_or_panic(v[429] == 43);
	8468	assert_or_panic(v[430] == 44);
	8469	assert_or_panic(v[431] == 45);
	8470	assert_or_panic(v[432] == 46);
	8471	assert_or_panic(v[433] == 47);
	8472	assert_or_panic(v[434] == 48);
	8473	assert_or_panic(v[435] == 49);
	8474	assert_or_panic(v[436] == 50);
	8475	assert_or_panic(v[437] == 51);
	8476	assert_or_panic(v[438] == 52);
	8477	assert_or_panic(v[439] == 53);
	8478	assert_or_panic(v[440] == 54);
	8479	assert_or_panic(v[441] == 55);
	8480	assert_or_panic(v[442] == 56);
	8481	assert_or_panic(v[443] == 57);
	8482	assert_or_panic(v[444] == 58);
	8483	assert_or_panic(v[445] == 59);
	8484	assert_or_panic(v[446] == 60);
	8485	assert_or_panic(v[447] == 61);
	8486	assert_or_panic(v[448] == 62);
	8487	assert_or_panic(v[449] == 63);
	8488	assert_or_panic(v[450] == 64);
	8489	assert_or_panic(v[451] == 65);
	8490	assert_or_panic(v[452] == 66);
	8491	assert_or_panic(v[453] == 67);
	8492	assert_or_panic(v[454] == 68);
	8493	assert_or_panic(v[455] == 69);
	8494	assert_or_panic(v[456] == 70);
	8495	assert_or_panic(v[457] == 71);
	8496	assert_or_panic(v[458] == 72);
	8497	assert_or_panic(v[459] == 73);
	8498	assert_or_panic(v[460] == 74);
	8499	assert_or_panic(v[461] == 75);
	8500	assert_or_panic(v[462] == 76);
	8501	assert_or_panic(v[463] == 77);
	8502	assert_or_panic(v[464] == 78);
	8503	assert_or_panic(v[465] == 79);
	8504	assert_or_panic(v[466] == 80);
	8505	assert_or_panic(v[467] == 81);
	8506	assert_or_panic(v[468] == 82);
	8507	assert_or_panic(v[469] == 83);
	8508	assert_or_panic(v[470] == 84);
	8509	assert_or_panic(v[471] == 85);
	8510	assert_or_panic(v[472] == 86);
	8511	assert_or_panic(v[473] == 87);
	8512	assert_or_panic(v[474] == 88);
	8513	assert_or_panic(v[475] == 89);
	8514	assert_or_panic(v[476] == 90);
	8515	assert_or_panic(v[477] == 91);
	8516	assert_or_panic(v[478] == 92);
	8517	assert_or_panic(v[479] == 93);
	8518	assert_or_panic(v[480] == 94);
	8519	assert_or_panic(v[481] == 95);
	8520	assert_or_panic(v[482] == 96);
	8521	assert_or_panic(v[483] == 97);
	8522	assert_or_panic(v[484] == 98);
	8523	assert_or_panic(v[485] == 99);
	8524	assert_or_panic(v[486] == 0);
	8525	assert_or_panic(v[487] == 1);
	8526	assert_or_panic(v[488] == 2);
	8527	assert_or_panic(v[489] == 3);
	8528	assert_or_panic(v[490] == 4);
	8529	assert_or_panic(v[491] == 5);
	8530	assert_or_panic(v[492] == 6);
	8531	assert_or_panic(v[493] == 7);
	8532	assert_or_panic(v[494] == 8);
	8533	assert_or_panic(v[495] == 9);
	8534	assert_or_panic(v[496] == 10);
	8535	assert_or_panic(v[497] == 11);
	8536	assert_or_panic(v[498] == 12);
	8537	assert_or_panic(v[499] == 13);
	8538	assert_or_panic(v[500] == 14);
	8539	assert_or_panic(v[501] == 15);
	8540	assert_or_panic(v[502] == 16);
	8541	assert_or_panic(v[503] == 17);
	8542	assert_or_panic(v[504] == 18);
	8543	assert_or_panic(v[505] == 19);
	8544	assert_or_panic(v[506] == 20);
	8545	assert_or_panic(v[507] == 21);
	8546	assert_or_panic(v[508] == 22);
	8547	assert_or_panic(v[509] == 23);
	8548	assert_or_panic(v[510] == 24);
	8549	assert_or_panic(v[511] == 25);
	8550	zig_vector_512_u8((Vector_512_u8){
	8551	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	8552	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	8553	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	8554	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	8555	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	8556	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	8557	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	8558	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	8559	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	8560	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	8561	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	8562	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	8563	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	8564	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	8565	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	8566	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	8567	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	8568	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	8569	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	8570	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	8571	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	8572	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	8573	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	8574	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	8575	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	8576	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	8577	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	8578	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	8579	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	8580	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	8581	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	8582	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	8583	}, 512);
	8584	}
	8585
	8586	typedef uint16_t Vector_1_u16 __attribute__((vector_size(1 * sizeof(uint16_t))));
	8587
	8588	Vector_1_u16 zig_ret_vector_1_u16(void);
	8589	void zig_vector_1_u16(Vector_1_u16, size_t);
	8590
	8591	Vector_1_u16 c_ret_vector_1_u16(void) {
	8592	return (Vector_1_u16){ 3 };
	8593	}
	8594	void c_vector_1_u16(Vector_1_u16 v, size_t i) {
	8595	assert_or_panic(v[0] == 4);
	8596	assert_or_panic(i == 1);
	8597	}
	8598	void c_test_vector_1_u16(void) {
	8599	Vector_1_u16 v = zig_ret_vector_1_u16();
	8600	assert_or_panic(v[0] == 1);
	8601	zig_vector_1_u16((Vector_1_u16){ 2 }, 1);
	8602	}
	8603
	8604	typedef uint16_t Vector_2_u16 __attribute__((vector_size(2 * sizeof(uint16_t))));
	8605
	8606	Vector_2_u16 zig_ret_vector_2_u16(void);
	8607	void zig_vector_2_u16(Vector_2_u16, size_t);
	8608
	8609	Vector_2_u16 c_ret_vector_2_u16(void) {
	8610	return (Vector_2_u16){ 9, 10 };
	8611	}
	8612	void c_vector_2_u16(Vector_2_u16 v, size_t i) {
	8613	assert_or_panic(v[0] == 11);
	8614	assert_or_panic(v[1] == 12);
	8615	assert_or_panic(i == 2);
	8616	}
	8617	void c_test_vector_2_u16(void) {
	8618	Vector_2_u16 v = zig_ret_vector_2_u16();
	8619	assert_or_panic(v[0] == 5);
	8620	assert_or_panic(v[1] == 6);
	8621	zig_vector_2_u16((Vector_2_u16){ 7, 8 }, 2);
	8622	}
	8623
	8624	typedef uint16_t Vector_3_u16 __attribute__((vector_size(3 * sizeof(uint16_t))));
	8625
	8626	Vector_3_u16 zig_ret_vector_3_u16(void);
	8627	void zig_vector_3_u16(Vector_3_u16, size_t);
	8628
	8629	Vector_3_u16 c_ret_vector_3_u16(void) {
	8630	return (Vector_3_u16){ 19, 20, 21 };
	8631	}
	8632	void c_vector_3_u16(Vector_3_u16 v, size_t i) {
	8633	assert_or_panic(v[0] == 22);
	8634	assert_or_panic(v[1] == 23);
	8635	assert_or_panic(v[2] == 24);
	8636	assert_or_panic(i == 3);
	8637	}
	8638	void c_test_vector_3_u16(void) {
	8639	Vector_3_u16 v = zig_ret_vector_3_u16();
	8640	assert_or_panic(v[0] == 13);
	8641	assert_or_panic(v[1] == 14);
	8642	assert_or_panic(v[2] == 15);
	8643	zig_vector_3_u16((Vector_3_u16){ 16, 17, 18 }, 3);
	8644	}
	8645
	8646	typedef uint16_t Vector_4_u16 __attribute__((vector_size(4 * sizeof(uint16_t))));
	8647
	8648	Vector_4_u16 zig_ret_vector_4_u16(void);
	8649
	8650	void zig_vector_4_u16(Vector_4_u16, size_t);
	8651	void zig_vector_4_u16_vector_4_u16(Vector_4_u16, Vector_4_u16, size_t);
	8652
	8653	Vector_4_u16 c_ret_vector_4_u16(void) {
	8654	return (Vector_4_u16){ 41, 42, 43, 44 };
	8655	}
	8656	void c_vector_4_u16(Vector_4_u16 v, size_t i) {
	8657	assert_or_panic(v[0] == 45);
	8658	assert_or_panic(v[1] == 46);
	8659	assert_or_panic(v[2] == 47);
	8660	assert_or_panic(v[3] == 48);
	8661	assert_or_panic(i == 4);
	8662	}
	8663	void c_vector_4_u16_vector_4_u16(Vector_4_u16 v0, Vector_4_u16 v1, size_t i) {
	8664	assert_or_panic(v0[0] == 49);
	8665	assert_or_panic(v0[1] == 50);
	8666	assert_or_panic(v0[2] == 51);
	8667	assert_or_panic(v0[3] == 52);
	8668	assert_or_panic(v1[0] == 53);
	8669	assert_or_panic(v1[1] == 54);
	8670	assert_or_panic(v1[2] == 55);
	8671	assert_or_panic(v1[3] == 56);
	8672	assert_or_panic(i == 8);
	8673	}
	8674	void c_test_vector_4_u16(void) {
	8675	Vector_4_u16 v = zig_ret_vector_4_u16();
	8676	assert_or_panic(v[0] == 25);
	8677	assert_or_panic(v[1] == 26);
	8678	assert_or_panic(v[2] == 27);
	8679	assert_or_panic(v[3] == 28);
	8680	zig_vector_4_u16((Vector_4_u16){ 29, 30, 31, 32 }, 4);
	8681	zig_vector_4_u16_vector_4_u16((Vector_4_u16){ 33, 34, 35, 36 }, (Vector_4_u16){ 37, 38, 39, 40 }, 8);
	8682	}
	8683
	8684	typedef uint16_t Vector_6_u16 __attribute__((vector_size(6 * sizeof(uint16_t))));
	8685
	8686	Vector_6_u16 zig_ret_vector_6_u16(void);
	8687	void zig_vector_6_u16(Vector_6_u16, size_t);
	8688
	8689	Vector_6_u16 c_ret_vector_6_u16(void) {
	8690	return (Vector_6_u16){ 53, 54, 55, 56, 57, 58 };
	8691	}
	8692	void c_vector_6_u16(Vector_6_u16 v, size_t i) {
	8693	assert_or_panic(v[0] == 59);
	8694	assert_or_panic(v[1] == 60);
	8695	assert_or_panic(v[2] == 61);
	8696	assert_or_panic(v[3] == 62);
	8697	assert_or_panic(v[4] == 63);
	8698	assert_or_panic(v[5] == 64);
	8699	assert_or_panic(i == 6);
	8700	}
	8701	void c_test_vector_6_u16(void) {
	8702	Vector_6_u16 v = zig_ret_vector_6_u16();
	8703	assert_or_panic(v[0] == 41);
	8704	assert_or_panic(v[1] == 42);
	8705	assert_or_panic(v[2] == 43);
	8706	assert_or_panic(v[3] == 44);
	8707	assert_or_panic(v[4] == 45);
	8708	assert_or_panic(v[5] == 46);
	8709	zig_vector_6_u16((Vector_6_u16){ 47, 48, 49, 50, 51, 52 }, 6);
	8710	}
	8711
	8712	typedef uint16_t Vector_8_u16 __attribute__((vector_size(8 * sizeof(uint16_t))));
	8713
	8714	Vector_8_u16 zig_ret_vector_8_u16(void);
	8715	void zig_vector_8_u16(Vector_8_u16, size_t);
	8716
	8717	Vector_8_u16 c_ret_vector_8_u16(void) {
	8718	return (Vector_8_u16){ 81, 82, 83, 84, 85, 86, 87, 88 };
	8719	}
	8720	void c_vector_8_u16(Vector_8_u16 v, size_t i) {
	8721	assert_or_panic(v[0] == 89);
	8722	assert_or_panic(v[1] == 90);
	8723	assert_or_panic(v[2] == 91);
	8724	assert_or_panic(v[3] == 92);
	8725	assert_or_panic(v[4] == 93);
	8726	assert_or_panic(v[5] == 94);
	8727	assert_or_panic(v[6] == 95);
	8728	assert_or_panic(v[7] == 96);
	8729	assert_or_panic(i == 8);
	8730	}
	8731	void c_test_vector_8_u16(void) {
	8732	Vector_8_u16 v = zig_ret_vector_8_u16();
	8733	assert_or_panic(v[0] == 65);
	8734	assert_or_panic(v[1] == 66);
	8735	assert_or_panic(v[2] == 67);
	8736	assert_or_panic(v[3] == 68);
	8737	assert_or_panic(v[4] == 69);
	8738	assert_or_panic(v[5] == 70);
	8739	assert_or_panic(v[6] == 71);
	8740	assert_or_panic(v[7] == 72);
	8741	zig_vector_8_u16((Vector_8_u16){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8);
	8742	}
	8743
	8744	typedef uint16_t Vector_12_u16 __attribute__((vector_size(12 * sizeof(uint16_t))));
	8745
	8746	Vector_12_u16 zig_ret_vector_12_u16(void);
	8747	void zig_vector_12_u16(Vector_12_u16, size_t);
	8748
	8749	Vector_12_u16 c_ret_vector_12_u16(void) {
	8750	return (Vector_12_u16){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 };
	8751	}
	8752	void c_vector_12_u16(Vector_12_u16 v, size_t i) {
	8753	assert_or_panic(v[0] == 133);
	8754	assert_or_panic(v[1] == 134);
	8755	assert_or_panic(v[2] == 135);
	8756	assert_or_panic(v[3] == 136);
	8757	assert_or_panic(v[4] == 137);
	8758	assert_or_panic(v[5] == 138);
	8759	assert_or_panic(v[6] == 139);
	8760	assert_or_panic(v[7] == 140);
	8761	assert_or_panic(v[8] == 141);
	8762	assert_or_panic(v[9] == 142);
	8763	assert_or_panic(v[10] == 143);
	8764	assert_or_panic(v[11] == 144);
	8765	assert_or_panic(i == 12);
	8766	}
	8767	void c_test_vector_12_u16(void) {
	8768	Vector_12_u16 v = zig_ret_vector_12_u16();
	8769	assert_or_panic(v[0] == 97);
	8770	assert_or_panic(v[1] == 98);
	8771	assert_or_panic(v[2] == 99);
	8772	assert_or_panic(v[3] == 100);
	8773	assert_or_panic(v[4] == 101);
	8774	assert_or_panic(v[5] == 102);
	8775	assert_or_panic(v[6] == 103);
	8776	assert_or_panic(v[7] == 104);
	8777	assert_or_panic(v[8] == 105);
	8778	assert_or_panic(v[9] == 106);
	8779	assert_or_panic(v[10] == 107);
	8780	assert_or_panic(v[11] == 108);
	8781	zig_vector_12_u16((Vector_12_u16){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12);
	8782	}
	8783
	8784	typedef uint16_t Vector_16_u16 __attribute__((vector_size(16 * sizeof(uint16_t))));
	8785
	8786	Vector_16_u16 zig_ret_vector_16_u16(void);
	8787	void zig_vector_16_u16(Vector_16_u16, size_t);
	8788
	8789	Vector_16_u16 c_ret_vector_16_u16(void) {
	8790	return (Vector_16_u16){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 };
	8791	}
	8792	void c_vector_16_u16(Vector_16_u16 v, size_t i) {
	8793	assert_or_panic(v[0] == 193);
	8794	assert_or_panic(v[1] == 194);
	8795	assert_or_panic(v[2] == 195);
	8796	assert_or_panic(v[3] == 196);
	8797	assert_or_panic(v[4] == 197);
	8798	assert_or_panic(v[5] == 198);
	8799	assert_or_panic(v[6] == 199);
	8800	assert_or_panic(v[7] == 200);
	8801	assert_or_panic(v[8] == 201);
	8802	assert_or_panic(v[9] == 202);
	8803	assert_or_panic(v[10] == 203);
	8804	assert_or_panic(v[11] == 204);
	8805	assert_or_panic(v[12] == 205);
	8806	assert_or_panic(v[13] == 206);
	8807	assert_or_panic(v[14] == 207);
	8808	assert_or_panic(v[15] == 208);
	8809	assert_or_panic(i == 16);
	8810	}
	8811	void c_test_vector_16_u16(void) {
	8812	Vector_16_u16 v = zig_ret_vector_16_u16();
	8813	assert_or_panic(v[0] == 145);
	8814	assert_or_panic(v[1] == 146);
	8815	assert_or_panic(v[2] == 147);
	8816	assert_or_panic(v[3] == 148);
	8817	assert_or_panic(v[4] == 149);
	8818	assert_or_panic(v[5] == 150);
	8819	assert_or_panic(v[6] == 151);
	8820	assert_or_panic(v[7] == 152);
	8821	assert_or_panic(v[8] == 153);
	8822	assert_or_panic(v[9] == 154);
	8823	assert_or_panic(v[10] == 155);
	8824	assert_or_panic(v[11] == 156);
	8825	assert_or_panic(v[12] == 157);
	8826	assert_or_panic(v[13] == 158);
	8827	assert_or_panic(v[14] == 159);
	8828	assert_or_panic(v[15] == 160);
	8829	zig_vector_16_u16((Vector_16_u16){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16);
	8830	}
	8831
	8832	typedef uint16_t Vector_24_u16 __attribute__((vector_size(24 * sizeof(uint16_t))));
	8833
	8834	Vector_24_u16 zig_ret_vector_24_u16(void);
	8835	void zig_vector_24_u16(Vector_24_u16, size_t);
	8836
	8837	Vector_24_u16 c_ret_vector_24_u16(void) {
	8838	return (Vector_24_u16){
	8839	257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
	8840	273, 274, 275, 276, 277, 278, 279, 280,
	8841	};
	8842	}
	8843	void c_vector_24_u16(Vector_24_u16 v, size_t i) {
	8844	assert_or_panic(v[0] == 281);
	8845	assert_or_panic(v[1] == 282);
	8846	assert_or_panic(v[2] == 283);
	8847	assert_or_panic(v[3] == 284);
	8848	assert_or_panic(v[4] == 285);
	8849	assert_or_panic(v[5] == 286);
	8850	assert_or_panic(v[6] == 287);
	8851	assert_or_panic(v[7] == 288);
	8852	assert_or_panic(v[8] == 289);
	8853	assert_or_panic(v[9] == 290);
	8854	assert_or_panic(v[10] == 291);
	8855	assert_or_panic(v[11] == 292);
	8856	assert_or_panic(v[12] == 293);
	8857	assert_or_panic(v[13] == 294);
	8858	assert_or_panic(v[14] == 295);
	8859	assert_or_panic(v[15] == 296);
	8860	assert_or_panic(v[16] == 297);
	8861	assert_or_panic(v[17] == 298);
	8862	assert_or_panic(v[18] == 299);
	8863	assert_or_panic(v[19] == 300);
	8864	assert_or_panic(v[20] == 301);
	8865	assert_or_panic(v[21] == 302);
	8866	assert_or_panic(v[22] == 303);
	8867	assert_or_panic(v[23] == 304);
	8868	assert_or_panic(i == 24);
	8869	}
	8870	void c_test_vector_24_u16(void) {
	8871	Vector_24_u16 v = zig_ret_vector_24_u16();
	8872	assert_or_panic(v[0] == 209);
	8873	assert_or_panic(v[1] == 210);
	8874	assert_or_panic(v[2] == 211);
	8875	assert_or_panic(v[3] == 212);
	8876	assert_or_panic(v[4] == 213);
	8877	assert_or_panic(v[5] == 214);
	8878	assert_or_panic(v[6] == 215);
	8879	assert_or_panic(v[7] == 216);
	8880	assert_or_panic(v[8] == 217);
	8881	assert_or_panic(v[9] == 218);
	8882	assert_or_panic(v[10] == 219);
	8883	assert_or_panic(v[11] == 220);
	8884	assert_or_panic(v[12] == 221);
	8885	assert_or_panic(v[13] == 222);
	8886	assert_or_panic(v[14] == 223);
	8887	assert_or_panic(v[15] == 224);
	8888	assert_or_panic(v[16] == 225);
	8889	assert_or_panic(v[17] == 226);
	8890	assert_or_panic(v[18] == 227);
	8891	assert_or_panic(v[19] == 228);
	8892	assert_or_panic(v[20] == 229);
	8893	assert_or_panic(v[21] == 230);
	8894	assert_or_panic(v[22] == 231);
	8895	assert_or_panic(v[23] == 232);
	8896	zig_vector_24_u16((Vector_24_u16){
	8897	233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
	8898	249, 250, 251, 252, 253, 254, 255, 256,
	8899	}, 24);
	8900	}
	8901
	8902	typedef uint16_t Vector_32_u16 __attribute__((vector_size(32 * sizeof(uint16_t))));
	8903
	8904	Vector_32_u16 zig_ret_vector_32_u16(void);
	8905	void zig_vector_32_u16(Vector_32_u16, size_t);
	8906
	8907	Vector_32_u16 c_ret_vector_32_u16(void) {
	8908	return (Vector_32_u16){
	8909	369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
	8910	385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400,
	8911	};
	8912	}
	8913	void c_vector_32_u16(Vector_32_u16 v, size_t i) {
	8914	assert_or_panic(v[0] == 401);
	8915	assert_or_panic(v[1] == 402);
	8916	assert_or_panic(v[2] == 403);
	8917	assert_or_panic(v[3] == 404);
	8918	assert_or_panic(v[4] == 405);
	8919	assert_or_panic(v[5] == 406);
	8920	assert_or_panic(v[6] == 407);
	8921	assert_or_panic(v[7] == 408);
	8922	assert_or_panic(v[8] == 409);
	8923	assert_or_panic(v[9] == 410);
	8924	assert_or_panic(v[10] == 411);
	8925	assert_or_panic(v[11] == 412);
	8926	assert_or_panic(v[12] == 413);
	8927	assert_or_panic(v[13] == 414);
	8928	assert_or_panic(v[14] == 415);
	8929	assert_or_panic(v[15] == 416);
	8930	assert_or_panic(v[16] == 417);
	8931	assert_or_panic(v[17] == 418);
	8932	assert_or_panic(v[18] == 419);
	8933	assert_or_panic(v[19] == 420);
	8934	assert_or_panic(v[20] == 421);
	8935	assert_or_panic(v[21] == 422);
	8936	assert_or_panic(v[22] == 423);
	8937	assert_or_panic(v[23] == 424);
	8938	assert_or_panic(v[24] == 425);
	8939	assert_or_panic(v[25] == 426);
	8940	assert_or_panic(v[26] == 427);
	8941	assert_or_panic(v[27] == 428);
	8942	assert_or_panic(v[28] == 429);
	8943	assert_or_panic(v[29] == 430);
	8944	assert_or_panic(v[30] == 431);
	8945	assert_or_panic(v[31] == 432);
	8946	assert_or_panic(i == 32);
	8947	}
	8948	void c_test_vector_32_u16(void) {
	8949	Vector_32_u16 v = zig_ret_vector_32_u16();
	8950	assert_or_panic(v[0] == 305);
	8951	assert_or_panic(v[1] == 306);
	8952	assert_or_panic(v[2] == 307);
	8953	assert_or_panic(v[3] == 308);
	8954	assert_or_panic(v[4] == 309);
	8955	assert_or_panic(v[5] == 310);
	8956	assert_or_panic(v[6] == 311);
	8957	assert_or_panic(v[7] == 312);
	8958	assert_or_panic(v[8] == 313);
	8959	assert_or_panic(v[9] == 314);
	8960	assert_or_panic(v[10] == 315);
	8961	assert_or_panic(v[11] == 316);
	8962	assert_or_panic(v[12] == 317);
	8963	assert_or_panic(v[13] == 318);
	8964	assert_or_panic(v[14] == 319);
	8965	assert_or_panic(v[15] == 320);
	8966	assert_or_panic(v[16] == 321);
	8967	assert_or_panic(v[17] == 322);
	8968	assert_or_panic(v[18] == 323);
	8969	assert_or_panic(v[19] == 324);
	8970	assert_or_panic(v[20] == 325);
	8971	assert_or_panic(v[21] == 326);
	8972	assert_or_panic(v[22] == 327);
	8973	assert_or_panic(v[23] == 328);
	8974	assert_or_panic(v[24] == 329);
	8975	assert_or_panic(v[25] == 330);
	8976	assert_or_panic(v[26] == 331);
	8977	assert_or_panic(v[27] == 332);
	8978	assert_or_panic(v[28] == 333);
	8979	assert_or_panic(v[29] == 334);
	8980	assert_or_panic(v[30] == 335);
	8981	assert_or_panic(v[31] == 336);
	8982	zig_vector_32_u16((Vector_32_u16){
	8983	337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
	8984	353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
	8985	}, 32);
	8986	}
	8987
	8988	typedef uint16_t Vector_48_u16 __attribute__((vector_size(48 * sizeof(uint16_t))));
	8989
	8990	Vector_48_u16 zig_ret_vector_48_u16(void);
	8991	void zig_vector_48_u16(Vector_48_u16, size_t);
	8992
	8993	Vector_48_u16 c_ret_vector_48_u16(void) {
	8994	return (Vector_48_u16){
	8995	529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544,
	8996	545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560,
	8997	561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576,
	8998	};
	8999	}
	9000	void c_vector_48_u16(Vector_48_u16 v, size_t i) {
	9001	assert_or_panic(v[0] == 577);
	9002	assert_or_panic(v[1] == 578);
	9003	assert_or_panic(v[2] == 579);
	9004	assert_or_panic(v[3] == 580);
	9005	assert_or_panic(v[4] == 581);
	9006	assert_or_panic(v[5] == 582);
	9007	assert_or_panic(v[6] == 583);
	9008	assert_or_panic(v[7] == 584);
	9009	assert_or_panic(v[8] == 585);
	9010	assert_or_panic(v[9] == 586);
	9011	assert_or_panic(v[10] == 587);
	9012	assert_or_panic(v[11] == 588);
	9013	assert_or_panic(v[12] == 589);
	9014	assert_or_panic(v[13] == 590);
	9015	assert_or_panic(v[14] == 591);
	9016	assert_or_panic(v[15] == 592);
	9017	assert_or_panic(v[16] == 593);
	9018	assert_or_panic(v[17] == 594);
	9019	assert_or_panic(v[18] == 595);
	9020	assert_or_panic(v[19] == 596);
	9021	assert_or_panic(v[20] == 597);
	9022	assert_or_panic(v[21] == 598);
	9023	assert_or_panic(v[22] == 599);
	9024	assert_or_panic(v[23] == 600);
	9025	assert_or_panic(v[24] == 601);
	9026	assert_or_panic(v[25] == 602);
	9027	assert_or_panic(v[26] == 603);
	9028	assert_or_panic(v[27] == 604);
	9029	assert_or_panic(v[28] == 605);
	9030	assert_or_panic(v[29] == 606);
	9031	assert_or_panic(v[30] == 607);
	9032	assert_or_panic(v[31] == 608);
	9033	assert_or_panic(v[32] == 609);
	9034	assert_or_panic(v[33] == 610);
	9035	assert_or_panic(v[34] == 611);
	9036	assert_or_panic(v[35] == 612);
	9037	assert_or_panic(v[36] == 613);
	9038	assert_or_panic(v[37] == 614);
	9039	assert_or_panic(v[38] == 615);
	9040	assert_or_panic(v[39] == 616);
	9041	assert_or_panic(v[40] == 617);
	9042	assert_or_panic(v[41] == 618);
	9043	assert_or_panic(v[42] == 619);
	9044	assert_or_panic(v[43] == 620);
	9045	assert_or_panic(v[44] == 621);
	9046	assert_or_panic(v[45] == 622);
	9047	assert_or_panic(v[46] == 623);
	9048	assert_or_panic(v[47] == 624);
	9049	assert_or_panic(i == 48);
	9050	}
	9051	void c_test_vector_48_u16(void) {
	9052	Vector_48_u16 v = zig_ret_vector_48_u16();
	9053	assert_or_panic(v[0] == 433);
	9054	assert_or_panic(v[1] == 434);
	9055	assert_or_panic(v[2] == 435);
	9056	assert_or_panic(v[3] == 436);
	9057	assert_or_panic(v[4] == 437);
	9058	assert_or_panic(v[5] == 438);
	9059	assert_or_panic(v[6] == 439);
	9060	assert_or_panic(v[7] == 440);
	9061	assert_or_panic(v[8] == 441);
	9062	assert_or_panic(v[9] == 442);
	9063	assert_or_panic(v[10] == 443);
	9064	assert_or_panic(v[11] == 444);
	9065	assert_or_panic(v[12] == 445);
	9066	assert_or_panic(v[13] == 446);
	9067	assert_or_panic(v[14] == 447);
	9068	assert_or_panic(v[15] == 448);
	9069	assert_or_panic(v[16] == 449);
	9070	assert_or_panic(v[17] == 450);
	9071	assert_or_panic(v[18] == 451);
	9072	assert_or_panic(v[19] == 452);
	9073	assert_or_panic(v[20] == 453);
	9074	assert_or_panic(v[21] == 454);
	9075	assert_or_panic(v[22] == 455);
	9076	assert_or_panic(v[23] == 456);
	9077	assert_or_panic(v[24] == 457);
	9078	assert_or_panic(v[25] == 458);
	9079	assert_or_panic(v[26] == 459);
	9080	assert_or_panic(v[27] == 460);
	9081	assert_or_panic(v[28] == 461);
	9082	assert_or_panic(v[29] == 462);
	9083	assert_or_panic(v[30] == 463);
	9084	assert_or_panic(v[31] == 464);
	9085	assert_or_panic(v[32] == 465);
	9086	assert_or_panic(v[33] == 466);
	9087	assert_or_panic(v[34] == 467);
	9088	assert_or_panic(v[35] == 468);
	9089	assert_or_panic(v[36] == 469);
	9090	assert_or_panic(v[37] == 470);
	9091	assert_or_panic(v[38] == 471);
	9092	assert_or_panic(v[39] == 472);
	9093	assert_or_panic(v[40] == 473);
	9094	assert_or_panic(v[41] == 474);
	9095	assert_or_panic(v[42] == 475);
	9096	assert_or_panic(v[43] == 476);
	9097	assert_or_panic(v[44] == 477);
	9098	assert_or_panic(v[45] == 478);
	9099	assert_or_panic(v[46] == 479);
	9100	assert_or_panic(v[47] == 480);
	9101	zig_vector_48_u16((Vector_48_u16){
	9102	481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496,
	9103	497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
	9104	513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
	9105	}, 48);
	9106	}
	9107
	9108	typedef uint16_t Vector_64_u16 __attribute__((vector_size(64 * sizeof(uint16_t))));
	9109
	9110	Vector_64_u16 zig_ret_vector_64_u16(void);
	9111	void zig_vector_64_u16(Vector_64_u16, size_t);
	9112
	9113	Vector_64_u16 c_ret_vector_64_u16(void) {
	9114	return (Vector_64_u16){
	9115	753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768,
	9116	769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784,
	9117	785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800,
	9118	801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816,
	9119	};
	9120	}
	9121	void c_vector_64_u16(Vector_64_u16 v, size_t i) {
	9122	assert_or_panic(v[0] == 817);
	9123	assert_or_panic(v[1] == 818);
	9124	assert_or_panic(v[2] == 819);
	9125	assert_or_panic(v[3] == 820);
	9126	assert_or_panic(v[4] == 821);
	9127	assert_or_panic(v[5] == 822);
	9128	assert_or_panic(v[6] == 823);
	9129	assert_or_panic(v[7] == 824);
	9130	assert_or_panic(v[8] == 825);
	9131	assert_or_panic(v[9] == 826);
	9132	assert_or_panic(v[10] == 827);
	9133	assert_or_panic(v[11] == 828);
	9134	assert_or_panic(v[12] == 829);
	9135	assert_or_panic(v[13] == 830);
	9136	assert_or_panic(v[14] == 831);
	9137	assert_or_panic(v[15] == 832);
	9138	assert_or_panic(v[16] == 833);
	9139	assert_or_panic(v[17] == 834);
	9140	assert_or_panic(v[18] == 835);
	9141	assert_or_panic(v[19] == 836);
	9142	assert_or_panic(v[20] == 837);
	9143	assert_or_panic(v[21] == 838);
	9144	assert_or_panic(v[22] == 839);
	9145	assert_or_panic(v[23] == 840);
	9146	assert_or_panic(v[24] == 841);
	9147	assert_or_panic(v[25] == 842);
	9148	assert_or_panic(v[26] == 843);
	9149	assert_or_panic(v[27] == 844);
	9150	assert_or_panic(v[28] == 845);
	9151	assert_or_panic(v[29] == 846);
	9152	assert_or_panic(v[30] == 847);
	9153	assert_or_panic(v[31] == 848);
	9154	assert_or_panic(v[32] == 849);
	9155	assert_or_panic(v[33] == 850);
	9156	assert_or_panic(v[34] == 851);
	9157	assert_or_panic(v[35] == 852);
	9158	assert_or_panic(v[36] == 853);
	9159	assert_or_panic(v[37] == 854);
	9160	assert_or_panic(v[38] == 855);
	9161	assert_or_panic(v[39] == 856);
	9162	assert_or_panic(v[40] == 857);
	9163	assert_or_panic(v[41] == 858);
	9164	assert_or_panic(v[42] == 859);
	9165	assert_or_panic(v[43] == 860);
	9166	assert_or_panic(v[44] == 861);
	9167	assert_or_panic(v[45] == 862);
	9168	assert_or_panic(v[46] == 863);
	9169	assert_or_panic(v[47] == 864);
	9170	assert_or_panic(v[48] == 865);
	9171	assert_or_panic(v[49] == 866);
	9172	assert_or_panic(v[50] == 867);
	9173	assert_or_panic(v[51] == 868);
	9174	assert_or_panic(v[52] == 869);
	9175	assert_or_panic(v[53] == 870);
	9176	assert_or_panic(v[54] == 871);
	9177	assert_or_panic(v[55] == 872);
	9178	assert_or_panic(v[56] == 873);
	9179	assert_or_panic(v[57] == 874);
	9180	assert_or_panic(v[58] == 875);
	9181	assert_or_panic(v[59] == 876);
	9182	assert_or_panic(v[60] == 877);
	9183	assert_or_panic(v[61] == 878);
	9184	assert_or_panic(v[62] == 879);
	9185	assert_or_panic(v[63] == 880);
	9186	assert_or_panic(i == 64);
	9187	}
	9188	void c_test_vector_64_u16(void) {
	9189	Vector_64_u16 v = zig_ret_vector_64_u16();
	9190	assert_or_panic(v[0] == 625);
	9191	assert_or_panic(v[1] == 626);
	9192	assert_or_panic(v[2] == 627);
	9193	assert_or_panic(v[3] == 628);
	9194	assert_or_panic(v[4] == 629);
	9195	assert_or_panic(v[5] == 630);
	9196	assert_or_panic(v[6] == 631);
	9197	assert_or_panic(v[7] == 632);
	9198	assert_or_panic(v[8] == 633);
	9199	assert_or_panic(v[9] == 634);
	9200	assert_or_panic(v[10] == 635);
	9201	assert_or_panic(v[11] == 636);
	9202	assert_or_panic(v[12] == 637);
	9203	assert_or_panic(v[13] == 638);
	9204	assert_or_panic(v[14] == 639);
	9205	assert_or_panic(v[15] == 640);
	9206	assert_or_panic(v[16] == 641);
	9207	assert_or_panic(v[17] == 642);
	9208	assert_or_panic(v[18] == 643);
	9209	assert_or_panic(v[19] == 644);
	9210	assert_or_panic(v[20] == 645);
	9211	assert_or_panic(v[21] == 646);
	9212	assert_or_panic(v[22] == 647);
	9213	assert_or_panic(v[23] == 648);
	9214	assert_or_panic(v[24] == 649);
	9215	assert_or_panic(v[25] == 650);
	9216	assert_or_panic(v[26] == 651);
	9217	assert_or_panic(v[27] == 652);
	9218	assert_or_panic(v[28] == 653);
	9219	assert_or_panic(v[29] == 654);
	9220	assert_or_panic(v[30] == 655);
	9221	assert_or_panic(v[31] == 656);
	9222	assert_or_panic(v[32] == 657);
	9223	assert_or_panic(v[33] == 658);
	9224	assert_or_panic(v[34] == 659);
	9225	assert_or_panic(v[35] == 660);
	9226	assert_or_panic(v[36] == 661);
	9227	assert_or_panic(v[37] == 662);
	9228	assert_or_panic(v[38] == 663);
	9229	assert_or_panic(v[39] == 664);
	9230	assert_or_panic(v[40] == 665);
	9231	assert_or_panic(v[41] == 666);
	9232	assert_or_panic(v[42] == 667);
	9233	assert_or_panic(v[43] == 668);
	9234	assert_or_panic(v[44] == 669);
	9235	assert_or_panic(v[45] == 670);
	9236	assert_or_panic(v[46] == 671);
	9237	assert_or_panic(v[47] == 672);
	9238	assert_or_panic(v[48] == 673);
	9239	assert_or_panic(v[49] == 674);
	9240	assert_or_panic(v[50] == 675);
	9241	assert_or_panic(v[51] == 676);
	9242	assert_or_panic(v[52] == 677);
	9243	assert_or_panic(v[53] == 678);
	9244	assert_or_panic(v[54] == 679);
	9245	assert_or_panic(v[55] == 680);
	9246	assert_or_panic(v[56] == 681);
	9247	assert_or_panic(v[57] == 682);
	9248	assert_or_panic(v[58] == 683);
	9249	assert_or_panic(v[59] == 684);
	9250	assert_or_panic(v[60] == 685);
	9251	assert_or_panic(v[61] == 686);
	9252	assert_or_panic(v[62] == 687);
	9253	assert_or_panic(v[63] == 688);
	9254	zig_vector_64_u16((Vector_64_u16){
	9255	689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704,
	9256	705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720,
	9257	721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736,
	9258	737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752,
	9259	}, 64);
	9260	}
	9261
	9262	typedef uint16_t Vector_96_u16 __attribute__((vector_size(96 * sizeof(uint16_t))));
	9263
	9264	Vector_96_u16 zig_ret_vector_96_u16(void);
	9265	void zig_vector_96_u16(Vector_96_u16, size_t);
	9266
	9267	Vector_96_u16 c_ret_vector_96_u16(void) {
	9268	return (Vector_96_u16){
	9269	1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097,
	9270	1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113,
	9271	1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129,
	9272	1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145,
	9273	1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161,
	9274	1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177,
	9275	};
	9276	}
	9277	void c_vector_96_u16(Vector_96_u16 v, size_t i) {
	9278	assert_or_panic(v[0] == 1178);
	9279	assert_or_panic(v[1] == 1179);
	9280	assert_or_panic(v[2] == 1180);
	9281	assert_or_panic(v[3] == 1181);
	9282	assert_or_panic(v[4] == 1182);
	9283	assert_or_panic(v[5] == 1183);
	9284	assert_or_panic(v[6] == 1184);
	9285	assert_or_panic(v[7] == 1185);
	9286	assert_or_panic(v[8] == 1186);
	9287	assert_or_panic(v[9] == 1187);
	9288	assert_or_panic(v[10] == 1188);
	9289	assert_or_panic(v[11] == 1189);
	9290	assert_or_panic(v[12] == 1190);
	9291	assert_or_panic(v[13] == 1191);
	9292	assert_or_panic(v[14] == 1192);
	9293	assert_or_panic(v[15] == 1193);
	9294	assert_or_panic(v[16] == 1194);
	9295	assert_or_panic(v[17] == 1195);
	9296	assert_or_panic(v[18] == 1196);
	9297	assert_or_panic(v[19] == 1197);
	9298	assert_or_panic(v[20] == 1198);
	9299	assert_or_panic(v[21] == 1199);
	9300	assert_or_panic(v[22] == 1200);
	9301	assert_or_panic(v[23] == 1201);
	9302	assert_or_panic(v[24] == 1202);
	9303	assert_or_panic(v[25] == 1203);
	9304	assert_or_panic(v[26] == 1204);
	9305	assert_or_panic(v[27] == 1205);
	9306	assert_or_panic(v[28] == 1206);
	9307	assert_or_panic(v[29] == 1207);
	9308	assert_or_panic(v[30] == 1208);
	9309	assert_or_panic(v[31] == 1209);
	9310	assert_or_panic(v[32] == 1210);
	9311	assert_or_panic(v[33] == 1211);
	9312	assert_or_panic(v[34] == 1212);
	9313	assert_or_panic(v[35] == 1213);
	9314	assert_or_panic(v[36] == 1214);
	9315	assert_or_panic(v[37] == 1215);
	9316	assert_or_panic(v[38] == 1216);
	9317	assert_or_panic(v[39] == 1217);
	9318	assert_or_panic(v[40] == 1218);
	9319	assert_or_panic(v[41] == 1219);
	9320	assert_or_panic(v[42] == 1220);
	9321	assert_or_panic(v[43] == 1221);
	9322	assert_or_panic(v[44] == 1222);
	9323	assert_or_panic(v[45] == 1223);
	9324	assert_or_panic(v[46] == 1224);
	9325	assert_or_panic(v[47] == 1225);
	9326	assert_or_panic(v[48] == 1226);
	9327	assert_or_panic(v[49] == 1227);
	9328	assert_or_panic(v[50] == 1228);
	9329	assert_or_panic(v[51] == 1229);
	9330	assert_or_panic(v[52] == 1230);
	9331	assert_or_panic(v[53] == 1231);
	9332	assert_or_panic(v[54] == 1232);
	9333	assert_or_panic(v[55] == 1233);
	9334	assert_or_panic(v[56] == 1234);
	9335	assert_or_panic(v[57] == 1235);
	9336	assert_or_panic(v[58] == 1236);
	9337	assert_or_panic(v[59] == 1237);
	9338	assert_or_panic(v[60] == 1238);
	9339	assert_or_panic(v[61] == 1239);
	9340	assert_or_panic(v[62] == 1240);
	9341	assert_or_panic(v[63] == 1241);
	9342	assert_or_panic(v[64] == 1242);
	9343	assert_or_panic(v[65] == 1243);
	9344	assert_or_panic(v[66] == 1244);
	9345	assert_or_panic(v[67] == 1245);
	9346	assert_or_panic(v[68] == 1246);
	9347	assert_or_panic(v[69] == 1247);
	9348	assert_or_panic(v[70] == 1248);
	9349	assert_or_panic(v[71] == 1249);
	9350	assert_or_panic(v[72] == 1250);
	9351	assert_or_panic(v[73] == 1251);
	9352	assert_or_panic(v[74] == 1252);
	9353	assert_or_panic(v[75] == 1253);
	9354	assert_or_panic(v[76] == 1254);
	9355	assert_or_panic(v[77] == 1255);
	9356	assert_or_panic(v[80] == 1258);
	9357	assert_or_panic(v[81] == 1259);
	9358	assert_or_panic(v[82] == 1260);
	9359	assert_or_panic(v[83] == 1261);
	9360	assert_or_panic(v[84] == 1262);
	9361	assert_or_panic(v[85] == 1263);
	9362	assert_or_panic(v[86] == 1264);
	9363	assert_or_panic(v[87] == 1265);
	9364	assert_or_panic(v[88] == 1266);
	9365	assert_or_panic(v[89] == 1267);
	9366	assert_or_panic(v[90] == 1268);
	9367	assert_or_panic(v[91] == 1269);
	9368	assert_or_panic(v[92] == 1270);
	9369	assert_or_panic(v[93] == 1271);
	9370	assert_or_panic(v[94] == 1272);
	9371	assert_or_panic(v[95] == 1273);
	9372	assert_or_panic(i == 96);
	9373	}
	9374	void c_test_vector_96_u16(void) {
	9375	Vector_96_u16 v = zig_ret_vector_96_u16();
	9376	assert_or_panic(v[0] == 890);
	9377	assert_or_panic(v[1] == 891);
	9378	assert_or_panic(v[2] == 892);
	9379	assert_or_panic(v[3] == 893);
	9380	assert_or_panic(v[4] == 894);
	9381	assert_or_panic(v[5] == 895);
	9382	assert_or_panic(v[6] == 896);
	9383	assert_or_panic(v[7] == 897);
	9384	assert_or_panic(v[8] == 898);
	9385	assert_or_panic(v[9] == 899);
	9386	assert_or_panic(v[10] == 900);
	9387	assert_or_panic(v[11] == 901);
	9388	assert_or_panic(v[12] == 902);
	9389	assert_or_panic(v[13] == 903);
	9390	assert_or_panic(v[14] == 904);
	9391	assert_or_panic(v[15] == 905);
	9392	assert_or_panic(v[16] == 906);
	9393	assert_or_panic(v[17] == 907);
	9394	assert_or_panic(v[18] == 908);
	9395	assert_or_panic(v[19] == 909);
	9396	assert_or_panic(v[20] == 910);
	9397	assert_or_panic(v[21] == 911);
	9398	assert_or_panic(v[22] == 912);
	9399	assert_or_panic(v[23] == 913);
	9400	assert_or_panic(v[24] == 914);
	9401	assert_or_panic(v[25] == 915);
	9402	assert_or_panic(v[26] == 916);
	9403	assert_or_panic(v[27] == 917);
	9404	assert_or_panic(v[28] == 918);
	9405	assert_or_panic(v[29] == 919);
	9406	assert_or_panic(v[30] == 920);
	9407	assert_or_panic(v[31] == 921);
	9408	assert_or_panic(v[32] == 922);
	9409	assert_or_panic(v[33] == 923);
	9410	assert_or_panic(v[34] == 924);
	9411	assert_or_panic(v[35] == 925);
	9412	assert_or_panic(v[36] == 926);
	9413	assert_or_panic(v[37] == 927);
	9414	assert_or_panic(v[38] == 928);
	9415	assert_or_panic(v[39] == 929);
	9416	assert_or_panic(v[40] == 930);
	9417	assert_or_panic(v[41] == 931);
	9418	assert_or_panic(v[42] == 932);
	9419	assert_or_panic(v[43] == 933);
	9420	assert_or_panic(v[44] == 934);
	9421	assert_or_panic(v[45] == 935);
	9422	assert_or_panic(v[46] == 936);
	9423	assert_or_panic(v[47] == 937);
	9424	assert_or_panic(v[48] == 938);
	9425	assert_or_panic(v[49] == 939);
	9426	assert_or_panic(v[50] == 940);
	9427	assert_or_panic(v[51] == 941);
	9428	assert_or_panic(v[52] == 942);
	9429	assert_or_panic(v[53] == 943);
	9430	assert_or_panic(v[54] == 944);
	9431	assert_or_panic(v[55] == 945);
	9432	assert_or_panic(v[56] == 946);
	9433	assert_or_panic(v[57] == 947);
	9434	assert_or_panic(v[58] == 948);
	9435	assert_or_panic(v[59] == 949);
	9436	assert_or_panic(v[60] == 950);
	9437	assert_or_panic(v[61] == 951);
	9438	assert_or_panic(v[62] == 952);
	9439	assert_or_panic(v[63] == 953);
	9440	assert_or_panic(v[64] == 954);
	9441	assert_or_panic(v[65] == 955);
	9442	assert_or_panic(v[66] == 956);
	9443	assert_or_panic(v[67] == 957);
	9444	assert_or_panic(v[68] == 958);
	9445	assert_or_panic(v[69] == 959);
	9446	assert_or_panic(v[70] == 960);
	9447	assert_or_panic(v[71] == 961);
	9448	assert_or_panic(v[72] == 962);
	9449	assert_or_panic(v[73] == 963);
	9450	assert_or_panic(v[74] == 964);
	9451	assert_or_panic(v[75] == 965);
	9452	assert_or_panic(v[76] == 966);
	9453	assert_or_panic(v[77] == 967);
	9454	assert_or_panic(v[78] == 968);
	9455	assert_or_panic(v[79] == 969);
	9456	assert_or_panic(v[80] == 970);
	9457	assert_or_panic(v[81] == 971);
	9458	assert_or_panic(v[82] == 972);
	9459	assert_or_panic(v[83] == 973);
	9460	assert_or_panic(v[84] == 974);
	9461	assert_or_panic(v[85] == 975);
	9462	assert_or_panic(v[86] == 976);
	9463	assert_or_panic(v[87] == 977);
	9464	assert_or_panic(v[88] == 978);
	9465	assert_or_panic(v[89] == 979);
	9466	assert_or_panic(v[90] == 980);
	9467	assert_or_panic(v[91] == 981);
	9468	assert_or_panic(v[92] == 982);
	9469	assert_or_panic(v[93] == 983);
	9470	assert_or_panic(v[94] == 984);
	9471	assert_or_panic(v[95] == 985);
	9472	zig_vector_96_u16((Vector_96_u16){
	9473	986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001,
	9474	1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017,
	9475	1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033,
	9476	1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049,
	9477	1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065,
	9478	1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081,
	9479	}, 96);
	9480	}
	9481
	9482	typedef uint16_t Vector_128_u16 __attribute__((vector_size(128 * sizeof(uint16_t))));
	9483
	9484	Vector_128_u16 zig_ret_vector_128_u16(void);
	9485	void zig_vector_128_u16(Vector_128_u16, size_t);
	9486
	9487	Vector_128_u16 c_ret_vector_128_u16(void) {
	9488	return (Vector_128_u16){
	9489	1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545,
	9490	1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561,
	9491	1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577,
	9492	1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593,
	9493	1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609,
	9494	1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625,
	9495	1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641,
	9496	1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657,
	9497	};
	9498	}
	9499	void c_vector_128_u16(Vector_128_u16 v, size_t i) {
	9500	assert_or_panic(v[0] == 1658);
	9501	assert_or_panic(v[1] == 1659);
	9502	assert_or_panic(v[2] == 1660);
	9503	assert_or_panic(v[3] == 1661);
	9504	assert_or_panic(v[4] == 1662);
	9505	assert_or_panic(v[5] == 1663);
	9506	assert_or_panic(v[6] == 1664);
	9507	assert_or_panic(v[7] == 1665);
	9508	assert_or_panic(v[8] == 1666);
	9509	assert_or_panic(v[9] == 1667);
	9510	assert_or_panic(v[10] == 1668);
	9511	assert_or_panic(v[11] == 1669);
	9512	assert_or_panic(v[12] == 1670);
	9513	assert_or_panic(v[13] == 1671);
	9514	assert_or_panic(v[14] == 1672);
	9515	assert_or_panic(v[15] == 1673);
	9516	assert_or_panic(v[16] == 1674);
	9517	assert_or_panic(v[17] == 1675);
	9518	assert_or_panic(v[18] == 1676);
	9519	assert_or_panic(v[19] == 1677);
	9520	assert_or_panic(v[20] == 1678);
	9521	assert_or_panic(v[21] == 1679);
	9522	assert_or_panic(v[22] == 1680);
	9523	assert_or_panic(v[23] == 1681);
	9524	assert_or_panic(v[24] == 1682);
	9525	assert_or_panic(v[25] == 1683);
	9526	assert_or_panic(v[26] == 1684);
	9527	assert_or_panic(v[27] == 1685);
	9528	assert_or_panic(v[28] == 1686);
	9529	assert_or_panic(v[29] == 1687);
	9530	assert_or_panic(v[30] == 1688);
	9531	assert_or_panic(v[31] == 1689);
	9532	assert_or_panic(v[32] == 1690);
	9533	assert_or_panic(v[33] == 1691);
	9534	assert_or_panic(v[34] == 1692);
	9535	assert_or_panic(v[35] == 1693);
	9536	assert_or_panic(v[36] == 1694);
	9537	assert_or_panic(v[37] == 1695);
	9538	assert_or_panic(v[38] == 1696);
	9539	assert_or_panic(v[39] == 1697);
	9540	assert_or_panic(v[40] == 1698);
	9541	assert_or_panic(v[41] == 1699);
	9542	assert_or_panic(v[42] == 1700);
	9543	assert_or_panic(v[43] == 1701);
	9544	assert_or_panic(v[44] == 1702);
	9545	assert_or_panic(v[45] == 1703);
	9546	assert_or_panic(v[46] == 1704);
	9547	assert_or_panic(v[47] == 1705);
	9548	assert_or_panic(v[48] == 1706);
	9549	assert_or_panic(v[49] == 1707);
	9550	assert_or_panic(v[50] == 1708);
	9551	assert_or_panic(v[51] == 1709);
	9552	assert_or_panic(v[52] == 1710);
	9553	assert_or_panic(v[53] == 1711);
	9554	assert_or_panic(v[54] == 1712);
	9555	assert_or_panic(v[55] == 1713);
	9556	assert_or_panic(v[56] == 1714);
	9557	assert_or_panic(v[57] == 1715);
	9558	assert_or_panic(v[58] == 1716);
	9559	assert_or_panic(v[59] == 1717);
	9560	assert_or_panic(v[60] == 1718);
	9561	assert_or_panic(v[61] == 1719);
	9562	assert_or_panic(v[62] == 1720);
	9563	assert_or_panic(v[63] == 1721);
	9564	assert_or_panic(v[64] == 1722);
	9565	assert_or_panic(v[65] == 1723);
	9566	assert_or_panic(v[66] == 1724);
	9567	assert_or_panic(v[67] == 1725);
	9568	assert_or_panic(v[68] == 1726);
	9569	assert_or_panic(v[69] == 1727);
	9570	assert_or_panic(v[70] == 1728);
	9571	assert_or_panic(v[71] == 1729);
	9572	assert_or_panic(v[72] == 1730);
	9573	assert_or_panic(v[73] == 1731);
	9574	assert_or_panic(v[74] == 1732);
	9575	assert_or_panic(v[75] == 1733);
	9576	assert_or_panic(v[76] == 1734);
	9577	assert_or_panic(v[77] == 1735);
	9578	assert_or_panic(v[78] == 1736);
	9579	assert_or_panic(v[79] == 1737);
	9580	assert_or_panic(v[80] == 1738);
	9581	assert_or_panic(v[81] == 1739);
	9582	assert_or_panic(v[82] == 1740);
	9583	assert_or_panic(v[83] == 1741);
	9584	assert_or_panic(v[84] == 1742);
	9585	assert_or_panic(v[85] == 1743);
	9586	assert_or_panic(v[86] == 1744);
	9587	assert_or_panic(v[87] == 1745);
	9588	assert_or_panic(v[88] == 1746);
	9589	assert_or_panic(v[89] == 1747);
	9590	assert_or_panic(v[90] == 1748);
	9591	assert_or_panic(v[91] == 1749);
	9592	assert_or_panic(v[92] == 1750);
	9593	assert_or_panic(v[93] == 1751);
	9594	assert_or_panic(v[94] == 1752);
	9595	assert_or_panic(v[95] == 1753);
	9596	assert_or_panic(v[96] == 1754);
	9597	assert_or_panic(v[97] == 1755);
	9598	assert_or_panic(v[98] == 1756);
	9599	assert_or_panic(v[99] == 1757);
	9600	assert_or_panic(v[100] == 1758);
	9601	assert_or_panic(v[101] == 1759);
	9602	assert_or_panic(v[102] == 1760);
	9603	assert_or_panic(v[103] == 1761);
	9604	assert_or_panic(v[104] == 1762);
	9605	assert_or_panic(v[105] == 1763);
	9606	assert_or_panic(v[106] == 1764);
	9607	assert_or_panic(v[107] == 1765);
	9608	assert_or_panic(v[108] == 1766);
	9609	assert_or_panic(v[109] == 1767);
	9610	assert_or_panic(v[110] == 1768);
	9611	assert_or_panic(v[111] == 1769);
	9612	assert_or_panic(v[112] == 1770);
	9613	assert_or_panic(v[113] == 1771);
	9614	assert_or_panic(v[114] == 1772);
	9615	assert_or_panic(v[115] == 1773);
	9616	assert_or_panic(v[116] == 1774);
	9617	assert_or_panic(v[117] == 1775);
	9618	assert_or_panic(v[118] == 1776);
	9619	assert_or_panic(v[119] == 1777);
	9620	assert_or_panic(v[120] == 1778);
	9621	assert_or_panic(v[121] == 1779);
	9622	assert_or_panic(v[122] == 1780);
	9623	assert_or_panic(v[123] == 1781);
	9624	assert_or_panic(v[124] == 1782);
	9625	assert_or_panic(v[125] == 1783);
	9626	assert_or_panic(v[126] == 1784);
	9627	assert_or_panic(v[127] == 1785);
	9628	assert_or_panic(i == 128);
	9629	}
	9630	void c_test_vector_128_u16(void) {
	9631	Vector_128_u16 v = zig_ret_vector_128_u16();
	9632	assert_or_panic(v[0] == 1274);
	9633	assert_or_panic(v[1] == 1275);
	9634	assert_or_panic(v[2] == 1276);
	9635	assert_or_panic(v[3] == 1277);
	9636	assert_or_panic(v[4] == 1278);
	9637	assert_or_panic(v[5] == 1279);
	9638	assert_or_panic(v[6] == 1280);
	9639	assert_or_panic(v[7] == 1281);
	9640	assert_or_panic(v[8] == 1282);
	9641	assert_or_panic(v[9] == 1283);
	9642	assert_or_panic(v[10] == 1284);
	9643	assert_or_panic(v[11] == 1285);
	9644	assert_or_panic(v[12] == 1286);
	9645	assert_or_panic(v[13] == 1287);
	9646	assert_or_panic(v[14] == 1288);
	9647	assert_or_panic(v[15] == 1289);
	9648	assert_or_panic(v[16] == 1290);
	9649	assert_or_panic(v[17] == 1291);
	9650	assert_or_panic(v[18] == 1292);
	9651	assert_or_panic(v[19] == 1293);
	9652	assert_or_panic(v[20] == 1294);
	9653	assert_or_panic(v[21] == 1295);
	9654	assert_or_panic(v[22] == 1296);
	9655	assert_or_panic(v[23] == 1297);
	9656	assert_or_panic(v[24] == 1298);
	9657	assert_or_panic(v[25] == 1299);
	9658	assert_or_panic(v[26] == 1300);
	9659	assert_or_panic(v[27] == 1301);
	9660	assert_or_panic(v[28] == 1302);
	9661	assert_or_panic(v[29] == 1303);
	9662	assert_or_panic(v[30] == 1304);
	9663	assert_or_panic(v[31] == 1305);
	9664	assert_or_panic(v[32] == 1306);
	9665	assert_or_panic(v[33] == 1307);
	9666	assert_or_panic(v[34] == 1308);
	9667	assert_or_panic(v[35] == 1309);
	9668	assert_or_panic(v[36] == 1310);
	9669	assert_or_panic(v[37] == 1311);
	9670	assert_or_panic(v[38] == 1312);
	9671	assert_or_panic(v[39] == 1313);
	9672	assert_or_panic(v[40] == 1314);
	9673	assert_or_panic(v[41] == 1315);
	9674	assert_or_panic(v[42] == 1316);
	9675	assert_or_panic(v[43] == 1317);
	9676	assert_or_panic(v[44] == 1318);
	9677	assert_or_panic(v[45] == 1319);
	9678	assert_or_panic(v[46] == 1320);
	9679	assert_or_panic(v[47] == 1321);
	9680	assert_or_panic(v[48] == 1322);
	9681	assert_or_panic(v[49] == 1323);
	9682	assert_or_panic(v[50] == 1324);
	9683	assert_or_panic(v[51] == 1325);
	9684	assert_or_panic(v[52] == 1326);
	9685	assert_or_panic(v[53] == 1327);
	9686	assert_or_panic(v[54] == 1328);
	9687	assert_or_panic(v[55] == 1329);
	9688	assert_or_panic(v[56] == 1330);
	9689	assert_or_panic(v[57] == 1331);
	9690	assert_or_panic(v[58] == 1332);
	9691	assert_or_panic(v[59] == 1333);
	9692	assert_or_panic(v[60] == 1334);
	9693	assert_or_panic(v[61] == 1335);
	9694	assert_or_panic(v[62] == 1336);
	9695	assert_or_panic(v[63] == 1337);
	9696	assert_or_panic(v[64] == 1338);
	9697	assert_or_panic(v[65] == 1339);
	9698	assert_or_panic(v[66] == 1340);
	9699	assert_or_panic(v[67] == 1341);
	9700	assert_or_panic(v[68] == 1342);
	9701	assert_or_panic(v[69] == 1343);
	9702	assert_or_panic(v[70] == 1344);
	9703	assert_or_panic(v[71] == 1345);
	9704	assert_or_panic(v[72] == 1346);
	9705	assert_or_panic(v[73] == 1347);
	9706	assert_or_panic(v[74] == 1348);
	9707	assert_or_panic(v[75] == 1349);
	9708	assert_or_panic(v[76] == 1350);
	9709	assert_or_panic(v[77] == 1351);
	9710	assert_or_panic(v[78] == 1352);
	9711	assert_or_panic(v[79] == 1353);
	9712	assert_or_panic(v[80] == 1354);
	9713	assert_or_panic(v[81] == 1355);
	9714	assert_or_panic(v[82] == 1356);
	9715	assert_or_panic(v[83] == 1357);
	9716	assert_or_panic(v[84] == 1358);
	9717	assert_or_panic(v[85] == 1359);
	9718	assert_or_panic(v[86] == 1360);
	9719	assert_or_panic(v[87] == 1361);
	9720	assert_or_panic(v[88] == 1362);
	9721	assert_or_panic(v[89] == 1363);
	9722	assert_or_panic(v[90] == 1364);
	9723	assert_or_panic(v[91] == 1365);
	9724	assert_or_panic(v[92] == 1366);
	9725	assert_or_panic(v[93] == 1367);
	9726	assert_or_panic(v[94] == 1368);
	9727	assert_or_panic(v[95] == 1369);
	9728	assert_or_panic(v[96] == 1370);
	9729	assert_or_panic(v[97] == 1371);
	9730	assert_or_panic(v[98] == 1372);
	9731	assert_or_panic(v[99] == 1373);
	9732	assert_or_panic(v[100] == 1374);
	9733	assert_or_panic(v[101] == 1375);
	9734	assert_or_panic(v[102] == 1376);
	9735	assert_or_panic(v[103] == 1377);
	9736	assert_or_panic(v[104] == 1378);
	9737	assert_or_panic(v[105] == 1379);
	9738	assert_or_panic(v[106] == 1380);
	9739	assert_or_panic(v[107] == 1381);
	9740	assert_or_panic(v[108] == 1382);
	9741	assert_or_panic(v[109] == 1383);
	9742	assert_or_panic(v[110] == 1384);
	9743	assert_or_panic(v[111] == 1385);
	9744	assert_or_panic(v[112] == 1386);
	9745	assert_or_panic(v[113] == 1387);
	9746	assert_or_panic(v[114] == 1388);
	9747	assert_or_panic(v[115] == 1389);
	9748	assert_or_panic(v[116] == 1390);
	9749	assert_or_panic(v[117] == 1391);
	9750	assert_or_panic(v[118] == 1392);
	9751	assert_or_panic(v[119] == 1393);
	9752	assert_or_panic(v[120] == 1394);
	9753	assert_or_panic(v[121] == 1395);
	9754	assert_or_panic(v[122] == 1396);
	9755	assert_or_panic(v[123] == 1397);
	9756	assert_or_panic(v[124] == 1398);
	9757	assert_or_panic(v[125] == 1399);
	9758	assert_or_panic(v[126] == 1400);
	9759	assert_or_panic(v[127] == 1401);
	9760	zig_vector_128_u16((Vector_128_u16){
	9761	1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417,
	9762	1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433,
	9763	1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449,
	9764	1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465,
	9765	1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481,
	9766	1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497,
	9767	1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513,
	9768	1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529,
	9769	}, 128);
	9770	}
	9771
	9772	typedef uint16_t Vector_192_u16 __attribute__((vector_size(192 * sizeof(uint16_t))));
	9773
	9774	Vector_192_u16 zig_ret_vector_192_u16(void);
	9775	void zig_vector_192_u16(Vector_192_u16, size_t);
	9776
	9777	Vector_192_u16 c_ret_vector_192_u16(void) {
	9778	return (Vector_192_u16){
	9779	2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, 2184, 2185,
	9780	2186, 2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, 2200, 2201,
	9781	2202, 2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217,
	9782	2218, 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, 2232, 2233,
	9783	2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 2242, 2243, 2244, 2245, 2246, 2247, 2248, 2249,
	9784	2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, 2265,
	9785	2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, 2278, 2279, 2280, 2281,
	9786	2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 2295, 2296, 2297,
	9787	2298, 2299, 2300, 2301, 2302, 2303, 2304, 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313,
	9788	2314, 2315, 2316, 2317, 2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329,
	9789	2330, 2331, 2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345,
	9790	2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, 2358, 2359, 2360, 2361,
	9791	};
	9792	}
	9793	void c_vector_192_u16(Vector_192_u16 v, size_t i) {
	9794	assert_or_panic(v[0] == 2362);
	9795	assert_or_panic(v[1] == 2363);
	9796	assert_or_panic(v[2] == 2364);
	9797	assert_or_panic(v[3] == 2365);
	9798	assert_or_panic(v[4] == 2366);
	9799	assert_or_panic(v[5] == 2367);
	9800	assert_or_panic(v[6] == 2368);
	9801	assert_or_panic(v[7] == 2369);
	9802	assert_or_panic(v[8] == 2370);
	9803	assert_or_panic(v[9] == 2371);
	9804	assert_or_panic(v[10] == 2372);
	9805	assert_or_panic(v[11] == 2373);
	9806	assert_or_panic(v[12] == 2374);
	9807	assert_or_panic(v[13] == 2375);
	9808	assert_or_panic(v[14] == 2376);
	9809	assert_or_panic(v[15] == 2377);
	9810	assert_or_panic(v[16] == 2378);
	9811	assert_or_panic(v[17] == 2379);
	9812	assert_or_panic(v[18] == 2380);
	9813	assert_or_panic(v[19] == 2381);
	9814	assert_or_panic(v[20] == 2382);
	9815	assert_or_panic(v[21] == 2383);
	9816	assert_or_panic(v[22] == 2384);
	9817	assert_or_panic(v[23] == 2385);
	9818	assert_or_panic(v[24] == 2386);
	9819	assert_or_panic(v[25] == 2387);
	9820	assert_or_panic(v[26] == 2388);
	9821	assert_or_panic(v[27] == 2389);
	9822	assert_or_panic(v[28] == 2390);
	9823	assert_or_panic(v[29] == 2391);
	9824	assert_or_panic(v[30] == 2392);
	9825	assert_or_panic(v[31] == 2393);
	9826	assert_or_panic(v[32] == 2394);
	9827	assert_or_panic(v[33] == 2395);
	9828	assert_or_panic(v[34] == 2396);
	9829	assert_or_panic(v[35] == 2397);
	9830	assert_or_panic(v[36] == 2398);
	9831	assert_or_panic(v[37] == 2399);
	9832	assert_or_panic(v[38] == 2400);
	9833	assert_or_panic(v[39] == 2401);
	9834	assert_or_panic(v[40] == 2402);
	9835	assert_or_panic(v[41] == 2403);
	9836	assert_or_panic(v[42] == 2404);
	9837	assert_or_panic(v[43] == 2405);
	9838	assert_or_panic(v[44] == 2406);
	9839	assert_or_panic(v[45] == 2407);
	9840	assert_or_panic(v[46] == 2408);
	9841	assert_or_panic(v[47] == 2409);
	9842	assert_or_panic(v[48] == 2410);
	9843	assert_or_panic(v[49] == 2411);
	9844	assert_or_panic(v[50] == 2412);
	9845	assert_or_panic(v[51] == 2413);
	9846	assert_or_panic(v[52] == 2414);
	9847	assert_or_panic(v[53] == 2415);
	9848	assert_or_panic(v[54] == 2416);
	9849	assert_or_panic(v[55] == 2417);
	9850	assert_or_panic(v[56] == 2418);
	9851	assert_or_panic(v[57] == 2419);
	9852	assert_or_panic(v[58] == 2420);
	9853	assert_or_panic(v[59] == 2421);
	9854	assert_or_panic(v[60] == 2422);
	9855	assert_or_panic(v[61] == 2423);
	9856	assert_or_panic(v[62] == 2424);
	9857	assert_or_panic(v[63] == 2425);
	9858	assert_or_panic(v[64] == 2426);
	9859	assert_or_panic(v[65] == 2427);
	9860	assert_or_panic(v[66] == 2428);
	9861	assert_or_panic(v[67] == 2429);
	9862	assert_or_panic(v[68] == 2430);
	9863	assert_or_panic(v[69] == 2431);
	9864	assert_or_panic(v[70] == 2432);
	9865	assert_or_panic(v[71] == 2433);
	9866	assert_or_panic(v[72] == 2434);
	9867	assert_or_panic(v[73] == 2435);
	9868	assert_or_panic(v[74] == 2436);
	9869	assert_or_panic(v[75] == 2437);
	9870	assert_or_panic(v[76] == 2438);
	9871	assert_or_panic(v[77] == 2439);
	9872	assert_or_panic(v[78] == 2440);
	9873	assert_or_panic(v[79] == 2441);
	9874	assert_or_panic(v[80] == 2442);
	9875	assert_or_panic(v[81] == 2443);
	9876	assert_or_panic(v[82] == 2444);
	9877	assert_or_panic(v[83] == 2445);
	9878	assert_or_panic(v[84] == 2446);
	9879	assert_or_panic(v[85] == 2447);
	9880	assert_or_panic(v[86] == 2448);
	9881	assert_or_panic(v[87] == 2449);
	9882	assert_or_panic(v[88] == 2450);
	9883	assert_or_panic(v[89] == 2451);
	9884	assert_or_panic(v[90] == 2452);
	9885	assert_or_panic(v[91] == 2453);
	9886	assert_or_panic(v[92] == 2454);
	9887	assert_or_panic(v[93] == 2455);
	9888	assert_or_panic(v[94] == 2456);
	9889	assert_or_panic(v[95] == 2457);
	9890	assert_or_panic(v[96] == 2458);
	9891	assert_or_panic(v[97] == 2459);
	9892	assert_or_panic(v[98] == 2460);
	9893	assert_or_panic(v[99] == 2461);
	9894	assert_or_panic(v[100] == 2462);
	9895	assert_or_panic(v[101] == 2463);
	9896	assert_or_panic(v[102] == 2464);
	9897	assert_or_panic(v[103] == 2465);
	9898	assert_or_panic(v[104] == 2466);
	9899	assert_or_panic(v[105] == 2467);
	9900	assert_or_panic(v[106] == 2468);
	9901	assert_or_panic(v[107] == 2469);
	9902	assert_or_panic(v[108] == 2470);
	9903	assert_or_panic(v[109] == 2471);
	9904	assert_or_panic(v[110] == 2472);
	9905	assert_or_panic(v[111] == 2473);
	9906	assert_or_panic(v[112] == 2474);
	9907	assert_or_panic(v[113] == 2475);
	9908	assert_or_panic(v[114] == 2476);
	9909	assert_or_panic(v[115] == 2477);
	9910	assert_or_panic(v[116] == 2478);
	9911	assert_or_panic(v[117] == 2479);
	9912	assert_or_panic(v[118] == 2480);
	9913	assert_or_panic(v[119] == 2481);
	9914	assert_or_panic(v[120] == 2482);
	9915	assert_or_panic(v[121] == 2483);
	9916	assert_or_panic(v[122] == 2484);
	9917	assert_or_panic(v[123] == 2485);
	9918	assert_or_panic(v[124] == 2486);
	9919	assert_or_panic(v[125] == 2487);
	9920	assert_or_panic(v[126] == 2488);
	9921	assert_or_panic(v[127] == 2489);
	9922	assert_or_panic(v[128] == 2490);
	9923	assert_or_panic(v[129] == 2491);
	9924	assert_or_panic(v[130] == 2492);
	9925	assert_or_panic(v[131] == 2493);
	9926	assert_or_panic(v[132] == 2494);
	9927	assert_or_panic(v[133] == 2495);
	9928	assert_or_panic(v[134] == 2496);
	9929	assert_or_panic(v[135] == 2497);
	9930	assert_or_panic(v[136] == 2498);
	9931	assert_or_panic(v[137] == 2499);
	9932	assert_or_panic(v[138] == 2500);
	9933	assert_or_panic(v[139] == 2501);
	9934	assert_or_panic(v[140] == 2502);
	9935	assert_or_panic(v[141] == 2503);
	9936	assert_or_panic(v[142] == 2504);
	9937	assert_or_panic(v[143] == 2505);
	9938	assert_or_panic(v[144] == 2506);
	9939	assert_or_panic(v[145] == 2507);
	9940	assert_or_panic(v[146] == 2508);
	9941	assert_or_panic(v[147] == 2509);
	9942	assert_or_panic(v[148] == 2510);
	9943	assert_or_panic(v[149] == 2511);
	9944	assert_or_panic(v[150] == 2512);
	9945	assert_or_panic(v[151] == 2513);
	9946	assert_or_panic(v[152] == 2514);
	9947	assert_or_panic(v[153] == 2515);
	9948	assert_or_panic(v[154] == 2516);
	9949	assert_or_panic(v[155] == 2517);
	9950	assert_or_panic(v[156] == 2518);
	9951	assert_or_panic(v[157] == 2519);
	9952	assert_or_panic(v[158] == 2520);
	9953	assert_or_panic(v[159] == 2521);
	9954	assert_or_panic(v[160] == 2522);
	9955	assert_or_panic(v[161] == 2523);
	9956	assert_or_panic(v[162] == 2524);
	9957	assert_or_panic(v[163] == 2525);
	9958	assert_or_panic(v[164] == 2526);
	9959	assert_or_panic(v[165] == 2527);
	9960	assert_or_panic(v[166] == 2528);
	9961	assert_or_panic(v[167] == 2529);
	9962	assert_or_panic(v[168] == 2530);
	9963	assert_or_panic(v[169] == 2531);
	9964	assert_or_panic(v[170] == 2532);
	9965	assert_or_panic(v[171] == 2533);
	9966	assert_or_panic(v[172] == 2534);
	9967	assert_or_panic(v[173] == 2535);
	9968	assert_or_panic(v[174] == 2536);
	9969	assert_or_panic(v[175] == 2537);
	9970	assert_or_panic(v[176] == 2538);
	9971	assert_or_panic(v[177] == 2539);
	9972	assert_or_panic(v[178] == 2540);
	9973	assert_or_panic(v[179] == 2541);
	9974	assert_or_panic(v[180] == 2542);
	9975	assert_or_panic(v[181] == 2543);
	9976	assert_or_panic(v[182] == 2544);
	9977	assert_or_panic(v[183] == 2545);
	9978	assert_or_panic(v[184] == 2546);
	9979	assert_or_panic(v[185] == 2547);
	9980	assert_or_panic(v[186] == 2548);
	9981	assert_or_panic(v[187] == 2549);
	9982	assert_or_panic(v[188] == 2550);
	9983	assert_or_panic(v[189] == 2551);
	9984	assert_or_panic(v[190] == 2552);
	9985	assert_or_panic(v[191] == 2553);
	9986	assert_or_panic(i == 192);
	9987	}
	9988	void c_test_vector_192_u16(void) {
	9989	Vector_192_u16 v = zig_ret_vector_192_u16();
	9990	assert_or_panic(v[0] == 1786);
	9991	assert_or_panic(v[1] == 1787);
	9992	assert_or_panic(v[2] == 1788);
	9993	assert_or_panic(v[3] == 1789);
	9994	assert_or_panic(v[4] == 1790);
	9995	assert_or_panic(v[5] == 1791);
	9996	assert_or_panic(v[6] == 1792);
	9997	assert_or_panic(v[7] == 1793);
	9998	assert_or_panic(v[8] == 1794);
	9999	assert_or_panic(v[9] == 1795);
	10000	assert_or_panic(v[10] == 1796);
	10001	assert_or_panic(v[11] == 1797);
	10002	assert_or_panic(v[12] == 1798);
	10003	assert_or_panic(v[13] == 1799);
	10004	assert_or_panic(v[14] == 1800);
	10005	assert_or_panic(v[15] == 1801);
	10006	assert_or_panic(v[16] == 1802);
	10007	assert_or_panic(v[17] == 1803);
	10008	assert_or_panic(v[18] == 1804);
	10009	assert_or_panic(v[19] == 1805);
	10010	assert_or_panic(v[20] == 1806);
	10011	assert_or_panic(v[21] == 1807);
	10012	assert_or_panic(v[22] == 1808);
	10013	assert_or_panic(v[23] == 1809);
	10014	assert_or_panic(v[24] == 1810);
	10015	assert_or_panic(v[25] == 1811);
	10016	assert_or_panic(v[26] == 1812);
	10017	assert_or_panic(v[27] == 1813);
	10018	assert_or_panic(v[28] == 1814);
	10019	assert_or_panic(v[29] == 1815);
	10020	assert_or_panic(v[30] == 1816);
	10021	assert_or_panic(v[31] == 1817);
	10022	assert_or_panic(v[32] == 1818);
	10023	assert_or_panic(v[33] == 1819);
	10024	assert_or_panic(v[34] == 1820);
	10025	assert_or_panic(v[35] == 1821);
	10026	assert_or_panic(v[36] == 1822);
	10027	assert_or_panic(v[37] == 1823);
	10028	assert_or_panic(v[38] == 1824);
	10029	assert_or_panic(v[39] == 1825);
	10030	assert_or_panic(v[40] == 1826);
	10031	assert_or_panic(v[41] == 1827);
	10032	assert_or_panic(v[42] == 1828);
	10033	assert_or_panic(v[43] == 1829);
	10034	assert_or_panic(v[44] == 1830);
	10035	assert_or_panic(v[45] == 1831);
	10036	assert_or_panic(v[46] == 1832);
	10037	assert_or_panic(v[47] == 1833);
	10038	assert_or_panic(v[48] == 1834);
	10039	assert_or_panic(v[49] == 1835);
	10040	assert_or_panic(v[50] == 1836);
	10041	assert_or_panic(v[51] == 1837);
	10042	assert_or_panic(v[52] == 1838);
	10043	assert_or_panic(v[53] == 1839);
	10044	assert_or_panic(v[54] == 1840);
	10045	assert_or_panic(v[55] == 1841);
	10046	assert_or_panic(v[56] == 1842);
	10047	assert_or_panic(v[57] == 1843);
	10048	assert_or_panic(v[58] == 1844);
	10049	assert_or_panic(v[59] == 1845);
	10050	assert_or_panic(v[60] == 1846);
	10051	assert_or_panic(v[61] == 1847);
	10052	assert_or_panic(v[62] == 1848);
	10053	assert_or_panic(v[63] == 1849);
	10054	assert_or_panic(v[64] == 1850);
	10055	assert_or_panic(v[65] == 1851);
	10056	assert_or_panic(v[66] == 1852);
	10057	assert_or_panic(v[67] == 1853);
	10058	assert_or_panic(v[68] == 1854);
	10059	assert_or_panic(v[69] == 1855);
	10060	assert_or_panic(v[70] == 1856);
	10061	assert_or_panic(v[71] == 1857);
	10062	assert_or_panic(v[72] == 1858);
	10063	assert_or_panic(v[73] == 1859);
	10064	assert_or_panic(v[74] == 1860);
	10065	assert_or_panic(v[75] == 1861);
	10066	assert_or_panic(v[76] == 1862);
	10067	assert_or_panic(v[77] == 1863);
	10068	assert_or_panic(v[78] == 1864);
	10069	assert_or_panic(v[79] == 1865);
	10070	assert_or_panic(v[80] == 1866);
	10071	assert_or_panic(v[81] == 1867);
	10072	assert_or_panic(v[82] == 1868);
	10073	assert_or_panic(v[83] == 1869);
	10074	assert_or_panic(v[84] == 1870);
	10075	assert_or_panic(v[85] == 1871);
	10076	assert_or_panic(v[86] == 1872);
	10077	assert_or_panic(v[87] == 1873);
	10078	assert_or_panic(v[88] == 1874);
	10079	assert_or_panic(v[89] == 1875);
	10080	assert_or_panic(v[90] == 1876);
	10081	assert_or_panic(v[91] == 1877);
	10082	assert_or_panic(v[92] == 1878);
	10083	assert_or_panic(v[93] == 1879);
	10084	assert_or_panic(v[94] == 1880);
	10085	assert_or_panic(v[95] == 1881);
	10086	assert_or_panic(v[96] == 1882);
	10087	assert_or_panic(v[97] == 1883);
	10088	assert_or_panic(v[98] == 1884);
	10089	assert_or_panic(v[99] == 1885);
	10090	assert_or_panic(v[100] == 1886);
	10091	assert_or_panic(v[101] == 1887);
	10092	assert_or_panic(v[102] == 1888);
	10093	assert_or_panic(v[103] == 1889);
	10094	assert_or_panic(v[104] == 1890);
	10095	assert_or_panic(v[105] == 1891);
	10096	assert_or_panic(v[106] == 1892);
	10097	assert_or_panic(v[107] == 1893);
	10098	assert_or_panic(v[108] == 1894);
	10099	assert_or_panic(v[109] == 1895);
	10100	assert_or_panic(v[110] == 1896);
	10101	assert_or_panic(v[111] == 1897);
	10102	assert_or_panic(v[112] == 1898);
	10103	assert_or_panic(v[113] == 1899);
	10104	assert_or_panic(v[114] == 1900);
	10105	assert_or_panic(v[115] == 1901);
	10106	assert_or_panic(v[116] == 1902);
	10107	assert_or_panic(v[117] == 1903);
	10108	assert_or_panic(v[118] == 1904);
	10109	assert_or_panic(v[119] == 1905);
	10110	assert_or_panic(v[120] == 1906);
	10111	assert_or_panic(v[121] == 1907);
	10112	assert_or_panic(v[122] == 1908);
	10113	assert_or_panic(v[123] == 1909);
	10114	assert_or_panic(v[124] == 1910);
	10115	assert_or_panic(v[125] == 1911);
	10116	assert_or_panic(v[126] == 1912);
	10117	assert_or_panic(v[127] == 1913);
	10118	assert_or_panic(v[128] == 1914);
	10119	assert_or_panic(v[129] == 1915);
	10120	assert_or_panic(v[130] == 1916);
	10121	assert_or_panic(v[131] == 1917);
	10122	assert_or_panic(v[132] == 1918);
	10123	assert_or_panic(v[133] == 1919);
	10124	assert_or_panic(v[134] == 1920);
	10125	assert_or_panic(v[135] == 1921);
	10126	assert_or_panic(v[136] == 1922);
	10127	assert_or_panic(v[137] == 1923);
	10128	assert_or_panic(v[138] == 1924);
	10129	assert_or_panic(v[139] == 1925);
	10130	assert_or_panic(v[140] == 1926);
	10131	assert_or_panic(v[141] == 1927);
	10132	assert_or_panic(v[142] == 1928);
	10133	assert_or_panic(v[143] == 1929);
	10134	assert_or_panic(v[144] == 1930);
	10135	assert_or_panic(v[145] == 1931);
	10136	assert_or_panic(v[146] == 1932);
	10137	assert_or_panic(v[147] == 1933);
	10138	assert_or_panic(v[148] == 1934);
	10139	assert_or_panic(v[149] == 1935);
	10140	assert_or_panic(v[150] == 1936);
	10141	assert_or_panic(v[151] == 1937);
	10142	assert_or_panic(v[152] == 1938);
	10143	assert_or_panic(v[153] == 1939);
	10144	assert_or_panic(v[154] == 1940);
	10145	assert_or_panic(v[155] == 1941);
	10146	assert_or_panic(v[156] == 1942);
	10147	assert_or_panic(v[157] == 1943);
	10148	assert_or_panic(v[158] == 1944);
	10149	assert_or_panic(v[159] == 1945);
	10150	assert_or_panic(v[160] == 1946);
	10151	assert_or_panic(v[161] == 1947);
	10152	assert_or_panic(v[162] == 1948);
	10153	assert_or_panic(v[163] == 1949);
	10154	assert_or_panic(v[164] == 1950);
	10155	assert_or_panic(v[165] == 1951);
	10156	assert_or_panic(v[166] == 1952);
	10157	assert_or_panic(v[167] == 1953);
	10158	assert_or_panic(v[168] == 1954);
	10159	assert_or_panic(v[169] == 1955);
	10160	assert_or_panic(v[170] == 1956);
	10161	assert_or_panic(v[171] == 1957);
	10162	assert_or_panic(v[172] == 1958);
	10163	assert_or_panic(v[173] == 1959);
	10164	assert_or_panic(v[174] == 1960);
	10165	assert_or_panic(v[175] == 1961);
	10166	assert_or_panic(v[176] == 1962);
	10167	assert_or_panic(v[177] == 1963);
	10168	assert_or_panic(v[178] == 1964);
	10169	assert_or_panic(v[179] == 1965);
	10170	assert_or_panic(v[180] == 1966);
	10171	assert_or_panic(v[181] == 1967);
	10172	assert_or_panic(v[182] == 1968);
	10173	assert_or_panic(v[183] == 1969);
	10174	assert_or_panic(v[184] == 1970);
	10175	assert_or_panic(v[185] == 1971);
	10176	assert_or_panic(v[186] == 1972);
	10177	assert_or_panic(v[187] == 1973);
	10178	assert_or_panic(v[188] == 1974);
	10179	assert_or_panic(v[189] == 1975);
	10180	assert_or_panic(v[190] == 1976);
	10181	assert_or_panic(v[191] == 1977);
	10182	zig_vector_192_u16((Vector_192_u16){
	10183	1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993,
	10184	1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
	10185	2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025,
	10186	2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041,
	10187	2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057,
	10188	2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073,
	10189	2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089,
	10190	2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 2104, 2105,
	10191	2106, 2107, 2108, 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121,
	10192	2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137,
	10193	2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149, 2150, 2151, 2152, 2153,
	10194	2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2168, 2169,
	10195	}, 192);
	10196	}
	10197
	10198	typedef uint16_t Vector_256_u16 __attribute__((vector_size(256 * sizeof(uint16_t))));
	10199
	10200	Vector_256_u16 zig_ret_vector_256_u16(void);
	10201	void zig_vector_256_u16(Vector_256_u16, size_t);
	10202
	10203	Vector_256_u16 c_ret_vector_256_u16(void) {
	10204	return (Vector_256_u16){
	10205	3066, 3067, 3068, 3069, 3070, 3071, 3072, 3073, 3074, 3075, 3076, 3077, 3078, 3079, 3080, 3081,
	10206	3082, 3083, 3084, 3085, 3086, 3087, 3088, 3089, 3090, 3091, 3092, 3093, 3094, 3095, 3096, 3097,
	10207	3098, 3099, 3100, 3101, 3102, 3103, 3104, 3105, 3106, 3107, 3108, 3109, 3110, 3111, 3112, 3113,
	10208	3114, 3115, 3116, 3117, 3118, 3119, 3120, 3121, 3122, 3123, 3124, 3125, 3126, 3127, 3128, 3129,
	10209	3130, 3131, 3132, 3133, 3134, 3135, 3136, 3137, 3138, 3139, 3140, 3141, 3142, 3143, 3144, 3145,
	10210	3146, 3147, 3148, 3149, 3150, 3151, 3152, 3153, 3154, 3155, 3156, 3157, 3158, 3159, 3160, 3161,
	10211	3162, 3163, 3164, 3165, 3166, 3167, 3168, 3169, 3170, 3171, 3172, 3173, 3174, 3175, 3176, 3177,
	10212	3178, 3179, 3180, 3181, 3182, 3183, 3184, 3185, 3186, 3187, 3188, 3189, 3190, 3191, 3192, 3193,
	10213	3194, 3195, 3196, 3197, 3198, 3199, 3200, 3201, 3202, 3203, 3204, 3205, 3206, 3207, 3208, 3209,
	10214	3210, 3211, 3212, 3213, 3214, 3215, 3216, 3217, 3218, 3219, 3220, 3221, 3222, 3223, 3224, 3225,
	10215	3226, 3227, 3228, 3229, 3230, 3231, 3232, 3233, 3234, 3235, 3236, 3237, 3238, 3239, 3240, 3241,
	10216	3242, 3243, 3244, 3245, 3246, 3247, 3248, 3249, 3250, 3251, 3252, 3253, 3254, 3255, 3256, 3257,
	10217	3258, 3259, 3260, 3261, 3262, 3263, 3264, 3265, 3266, 3267, 3268, 3269, 3270, 3271, 3272, 3273,
	10218	3274, 3275, 3276, 3277, 3278, 3279, 3280, 3281, 3282, 3283, 3284, 3285, 3286, 3287, 3288, 3289,
	10219	3290, 3291, 3292, 3293, 3294, 3295, 3296, 3297, 3298, 3299, 3300, 3301, 3302, 3303, 3304, 3305,
	10220	3306, 3307, 3308, 3309, 3310, 3311, 3312, 3313, 3314, 3315, 3316, 3317, 3318, 3319, 3320, 3321,
	10221	};
	10222	}
	10223	void c_vector_256_u16(Vector_256_u16 v, size_t i) {
	10224	assert_or_panic(v[0] == 3322);
	10225	assert_or_panic(v[1] == 3323);
	10226	assert_or_panic(v[2] == 3324);
	10227	assert_or_panic(v[3] == 3325);
	10228	assert_or_panic(v[4] == 3326);
	10229	assert_or_panic(v[5] == 3327);
	10230	assert_or_panic(v[6] == 3328);
	10231	assert_or_panic(v[7] == 3329);
	10232	assert_or_panic(v[8] == 3330);
	10233	assert_or_panic(v[9] == 3331);
	10234	assert_or_panic(v[10] == 3332);
	10235	assert_or_panic(v[11] == 3333);
	10236	assert_or_panic(v[12] == 3334);
	10237	assert_or_panic(v[13] == 3335);
	10238	assert_or_panic(v[14] == 3336);
	10239	assert_or_panic(v[15] == 3337);
	10240	assert_or_panic(v[16] == 3338);
	10241	assert_or_panic(v[17] == 3339);
	10242	assert_or_panic(v[18] == 3340);
	10243	assert_or_panic(v[19] == 3341);
	10244	assert_or_panic(v[20] == 3342);
	10245	assert_or_panic(v[21] == 3343);
	10246	assert_or_panic(v[22] == 3344);
	10247	assert_or_panic(v[23] == 3345);
	10248	assert_or_panic(v[24] == 3346);
	10249	assert_or_panic(v[25] == 3347);
	10250	assert_or_panic(v[26] == 3348);
	10251	assert_or_panic(v[27] == 3349);
	10252	assert_or_panic(v[28] == 3350);
	10253	assert_or_panic(v[29] == 3351);
	10254	assert_or_panic(v[30] == 3352);
	10255	assert_or_panic(v[31] == 3353);
	10256	assert_or_panic(v[32] == 3354);
	10257	assert_or_panic(v[33] == 3355);
	10258	assert_or_panic(v[34] == 3356);
	10259	assert_or_panic(v[35] == 3357);
	10260	assert_or_panic(v[36] == 3358);
	10261	assert_or_panic(v[37] == 3359);
	10262	assert_or_panic(v[38] == 3360);
	10263	assert_or_panic(v[39] == 3361);
	10264	assert_or_panic(v[40] == 3362);
	10265	assert_or_panic(v[41] == 3363);
	10266	assert_or_panic(v[42] == 3364);
	10267	assert_or_panic(v[43] == 3365);
	10268	assert_or_panic(v[44] == 3366);
	10269	assert_or_panic(v[45] == 3367);
	10270	assert_or_panic(v[46] == 3368);
	10271	assert_or_panic(v[47] == 3369);
	10272	assert_or_panic(v[48] == 3370);
	10273	assert_or_panic(v[49] == 3371);
	10274	assert_or_panic(v[50] == 3372);
	10275	assert_or_panic(v[51] == 3373);
	10276	assert_or_panic(v[52] == 3374);
	10277	assert_or_panic(v[53] == 3375);
	10278	assert_or_panic(v[54] == 3376);
	10279	assert_or_panic(v[55] == 3377);
	10280	assert_or_panic(v[56] == 3378);
	10281	assert_or_panic(v[57] == 3379);
	10282	assert_or_panic(v[58] == 3380);
	10283	assert_or_panic(v[59] == 3381);
	10284	assert_or_panic(v[60] == 3382);
	10285	assert_or_panic(v[61] == 3383);
	10286	assert_or_panic(v[62] == 3384);
	10287	assert_or_panic(v[63] == 3385);
	10288	assert_or_panic(v[64] == 3386);
	10289	assert_or_panic(v[65] == 3387);
	10290	assert_or_panic(v[66] == 3388);
	10291	assert_or_panic(v[67] == 3389);
	10292	assert_or_panic(v[68] == 3390);
	10293	assert_or_panic(v[69] == 3391);
	10294	assert_or_panic(v[70] == 3392);
	10295	assert_or_panic(v[71] == 3393);
	10296	assert_or_panic(v[72] == 3394);
	10297	assert_or_panic(v[73] == 3395);
	10298	assert_or_panic(v[74] == 3396);
	10299	assert_or_panic(v[75] == 3397);
	10300	assert_or_panic(v[76] == 3398);
	10301	assert_or_panic(v[77] == 3399);
	10302	assert_or_panic(v[78] == 3400);
	10303	assert_or_panic(v[79] == 3401);
	10304	assert_or_panic(v[80] == 3402);
	10305	assert_or_panic(v[81] == 3403);
	10306	assert_or_panic(v[82] == 3404);
	10307	assert_or_panic(v[83] == 3405);
	10308	assert_or_panic(v[84] == 3406);
	10309	assert_or_panic(v[85] == 3407);
	10310	assert_or_panic(v[86] == 3408);
	10311	assert_or_panic(v[87] == 3409);
	10312	assert_or_panic(v[88] == 3410);
	10313	assert_or_panic(v[89] == 3411);
	10314	assert_or_panic(v[90] == 3412);
	10315	assert_or_panic(v[91] == 3413);
	10316	assert_or_panic(v[92] == 3414);
	10317	assert_or_panic(v[93] == 3415);
	10318	assert_or_panic(v[94] == 3416);
	10319	assert_or_panic(v[95] == 3417);
	10320	assert_or_panic(v[96] == 3418);
	10321	assert_or_panic(v[97] == 3419);
	10322	assert_or_panic(v[98] == 3420);
	10323	assert_or_panic(v[99] == 3421);
	10324	assert_or_panic(v[100] == 3422);
	10325	assert_or_panic(v[101] == 3423);
	10326	assert_or_panic(v[102] == 3424);
	10327	assert_or_panic(v[103] == 3425);
	10328	assert_or_panic(v[104] == 3426);
	10329	assert_or_panic(v[105] == 3427);
	10330	assert_or_panic(v[106] == 3428);
	10331	assert_or_panic(v[107] == 3429);
	10332	assert_or_panic(v[108] == 3430);
	10333	assert_or_panic(v[109] == 3431);
	10334	assert_or_panic(v[110] == 3432);
	10335	assert_or_panic(v[111] == 3433);
	10336	assert_or_panic(v[112] == 3434);
	10337	assert_or_panic(v[113] == 3435);
	10338	assert_or_panic(v[114] == 3436);
	10339	assert_or_panic(v[115] == 3437);
	10340	assert_or_panic(v[116] == 3438);
	10341	assert_or_panic(v[117] == 3439);
	10342	assert_or_panic(v[118] == 3440);
	10343	assert_or_panic(v[119] == 3441);
	10344	assert_or_panic(v[120] == 3442);
	10345	assert_or_panic(v[121] == 3443);
	10346	assert_or_panic(v[122] == 3444);
	10347	assert_or_panic(v[123] == 3445);
	10348	assert_or_panic(v[124] == 3446);
	10349	assert_or_panic(v[125] == 3447);
	10350	assert_or_panic(v[126] == 3448);
	10351	assert_or_panic(v[127] == 3449);
	10352	assert_or_panic(v[128] == 3450);
	10353	assert_or_panic(v[129] == 3451);
	10354	assert_or_panic(v[130] == 3452);
	10355	assert_or_panic(v[131] == 3453);
	10356	assert_or_panic(v[132] == 3454);
	10357	assert_or_panic(v[133] == 3455);
	10358	assert_or_panic(v[134] == 3456);
	10359	assert_or_panic(v[135] == 3457);
	10360	assert_or_panic(v[136] == 3458);
	10361	assert_or_panic(v[137] == 3459);
	10362	assert_or_panic(v[138] == 3460);
	10363	assert_or_panic(v[139] == 3461);
	10364	assert_or_panic(v[140] == 3462);
	10365	assert_or_panic(v[141] == 3463);
	10366	assert_or_panic(v[142] == 3464);
	10367	assert_or_panic(v[143] == 3465);
	10368	assert_or_panic(v[144] == 3466);
	10369	assert_or_panic(v[145] == 3467);
	10370	assert_or_panic(v[146] == 3468);
	10371	assert_or_panic(v[147] == 3469);
	10372	assert_or_panic(v[148] == 3470);
	10373	assert_or_panic(v[149] == 3471);
	10374	assert_or_panic(v[150] == 3472);
	10375	assert_or_panic(v[151] == 3473);
	10376	assert_or_panic(v[152] == 3474);
	10377	assert_or_panic(v[153] == 3475);
	10378	assert_or_panic(v[154] == 3476);
	10379	assert_or_panic(v[155] == 3477);
	10380	assert_or_panic(v[156] == 3478);
	10381	assert_or_panic(v[157] == 3479);
	10382	assert_or_panic(v[158] == 3480);
	10383	assert_or_panic(v[159] == 3481);
	10384	assert_or_panic(v[160] == 3482);
	10385	assert_or_panic(v[161] == 3483);
	10386	assert_or_panic(v[162] == 3484);
	10387	assert_or_panic(v[163] == 3485);
	10388	assert_or_panic(v[164] == 3486);
	10389	assert_or_panic(v[165] == 3487);
	10390	assert_or_panic(v[166] == 3488);
	10391	assert_or_panic(v[167] == 3489);
	10392	assert_or_panic(v[168] == 3490);
	10393	assert_or_panic(v[169] == 3491);
	10394	assert_or_panic(v[170] == 3492);
	10395	assert_or_panic(v[171] == 3493);
	10396	assert_or_panic(v[172] == 3494);
	10397	assert_or_panic(v[173] == 3495);
	10398	assert_or_panic(v[174] == 3496);
	10399	assert_or_panic(v[175] == 3497);
	10400	assert_or_panic(v[176] == 3498);
	10401	assert_or_panic(v[177] == 3499);
	10402	assert_or_panic(v[178] == 3500);
	10403	assert_or_panic(v[179] == 3501);
	10404	assert_or_panic(v[180] == 3502);
	10405	assert_or_panic(v[181] == 3503);
	10406	assert_or_panic(v[182] == 3504);
	10407	assert_or_panic(v[183] == 3505);
	10408	assert_or_panic(v[184] == 3506);
	10409	assert_or_panic(v[185] == 3507);
	10410	assert_or_panic(v[186] == 3508);
	10411	assert_or_panic(v[187] == 3509);
	10412	assert_or_panic(v[188] == 3510);
	10413	assert_or_panic(v[189] == 3511);
	10414	assert_or_panic(v[190] == 3512);
	10415	assert_or_panic(v[191] == 3513);
	10416	assert_or_panic(v[192] == 3514);
	10417	assert_or_panic(v[193] == 3515);
	10418	assert_or_panic(v[194] == 3516);
	10419	assert_or_panic(v[195] == 3517);
	10420	assert_or_panic(v[196] == 3518);
	10421	assert_or_panic(v[197] == 3519);
	10422	assert_or_panic(v[198] == 3520);
	10423	assert_or_panic(v[199] == 3521);
	10424	assert_or_panic(v[200] == 3522);
	10425	assert_or_panic(v[201] == 3523);
	10426	assert_or_panic(v[202] == 3524);
	10427	assert_or_panic(v[203] == 3525);
	10428	assert_or_panic(v[204] == 3526);
	10429	assert_or_panic(v[205] == 3527);
	10430	assert_or_panic(v[206] == 3528);
	10431	assert_or_panic(v[207] == 3529);
	10432	assert_or_panic(v[208] == 3530);
	10433	assert_or_panic(v[209] == 3531);
	10434	assert_or_panic(v[210] == 3532);
	10435	assert_or_panic(v[211] == 3533);
	10436	assert_or_panic(v[212] == 3534);
	10437	assert_or_panic(v[213] == 3535);
	10438	assert_or_panic(v[214] == 3536);
	10439	assert_or_panic(v[215] == 3537);
	10440	assert_or_panic(v[216] == 3538);
	10441	assert_or_panic(v[217] == 3539);
	10442	assert_or_panic(v[218] == 3540);
	10443	assert_or_panic(v[219] == 3541);
	10444	assert_or_panic(v[220] == 3542);
	10445	assert_or_panic(v[221] == 3543);
	10446	assert_or_panic(v[222] == 3544);
	10447	assert_or_panic(v[223] == 3545);
	10448	assert_or_panic(v[224] == 3546);
	10449	assert_or_panic(v[225] == 3547);
	10450	assert_or_panic(v[226] == 3548);
	10451	assert_or_panic(v[227] == 3549);
	10452	assert_or_panic(v[228] == 3550);
	10453	assert_or_panic(v[229] == 3551);
	10454	assert_or_panic(v[230] == 3552);
	10455	assert_or_panic(v[231] == 3553);
	10456	assert_or_panic(v[232] == 3554);
	10457	assert_or_panic(v[233] == 3555);
	10458	assert_or_panic(v[234] == 3556);
	10459	assert_or_panic(v[235] == 3557);
	10460	assert_or_panic(v[236] == 3558);
	10461	assert_or_panic(v[237] == 3559);
	10462	assert_or_panic(v[238] == 3560);
	10463	assert_or_panic(v[239] == 3561);
	10464	assert_or_panic(v[240] == 3562);
	10465	assert_or_panic(v[241] == 3563);
	10466	assert_or_panic(v[242] == 3564);
	10467	assert_or_panic(v[243] == 3565);
	10468	assert_or_panic(v[244] == 3566);
	10469	assert_or_panic(v[245] == 3567);
	10470	assert_or_panic(v[246] == 3568);
	10471	assert_or_panic(v[247] == 3569);
	10472	assert_or_panic(v[248] == 3570);
	10473	assert_or_panic(v[249] == 3571);
	10474	assert_or_panic(v[250] == 3572);
	10475	assert_or_panic(v[251] == 3573);
	10476	assert_or_panic(v[252] == 3574);
	10477	assert_or_panic(v[253] == 3575);
	10478	assert_or_panic(v[254] == 3576);
	10479	assert_or_panic(v[255] == 3577);
	10480	assert_or_panic(i == 256);
	10481	}
	10482	void c_test_vector_256_u16(void) {
	10483	Vector_256_u16 v = zig_ret_vector_256_u16();
	10484	assert_or_panic(v[0] == 2554);
	10485	assert_or_panic(v[1] == 2555);
	10486	assert_or_panic(v[2] == 2556);
	10487	assert_or_panic(v[3] == 2557);
	10488	assert_or_panic(v[4] == 2558);
	10489	assert_or_panic(v[5] == 2559);
	10490	assert_or_panic(v[6] == 2560);
	10491	assert_or_panic(v[7] == 2561);
	10492	assert_or_panic(v[8] == 2562);
	10493	assert_or_panic(v[9] == 2563);
	10494	assert_or_panic(v[10] == 2564);
	10495	assert_or_panic(v[11] == 2565);
	10496	assert_or_panic(v[12] == 2566);
	10497	assert_or_panic(v[13] == 2567);
	10498	assert_or_panic(v[14] == 2568);
	10499	assert_or_panic(v[15] == 2569);
	10500	assert_or_panic(v[16] == 2570);
	10501	assert_or_panic(v[17] == 2571);
	10502	assert_or_panic(v[18] == 2572);
	10503	assert_or_panic(v[19] == 2573);
	10504	assert_or_panic(v[20] == 2574);
	10505	assert_or_panic(v[21] == 2575);
	10506	assert_or_panic(v[22] == 2576);
	10507	assert_or_panic(v[23] == 2577);
	10508	assert_or_panic(v[24] == 2578);
	10509	assert_or_panic(v[25] == 2579);
	10510	assert_or_panic(v[26] == 2580);
	10511	assert_or_panic(v[27] == 2581);
	10512	assert_or_panic(v[28] == 2582);
	10513	assert_or_panic(v[29] == 2583);
	10514	assert_or_panic(v[30] == 2584);
	10515	assert_or_panic(v[31] == 2585);
	10516	assert_or_panic(v[32] == 2586);
	10517	assert_or_panic(v[33] == 2587);
	10518	assert_or_panic(v[34] == 2588);
	10519	assert_or_panic(v[35] == 2589);
	10520	assert_or_panic(v[36] == 2590);
	10521	assert_or_panic(v[37] == 2591);
	10522	assert_or_panic(v[38] == 2592);
	10523	assert_or_panic(v[39] == 2593);
	10524	assert_or_panic(v[40] == 2594);
	10525	assert_or_panic(v[41] == 2595);
	10526	assert_or_panic(v[42] == 2596);
	10527	assert_or_panic(v[43] == 2597);
	10528	assert_or_panic(v[44] == 2598);
	10529	assert_or_panic(v[45] == 2599);
	10530	assert_or_panic(v[46] == 2600);
	10531	assert_or_panic(v[47] == 2601);
	10532	assert_or_panic(v[48] == 2602);
	10533	assert_or_panic(v[49] == 2603);
	10534	assert_or_panic(v[50] == 2604);
	10535	assert_or_panic(v[51] == 2605);
	10536	assert_or_panic(v[52] == 2606);
	10537	assert_or_panic(v[53] == 2607);
	10538	assert_or_panic(v[54] == 2608);
	10539	assert_or_panic(v[55] == 2609);
	10540	assert_or_panic(v[56] == 2610);
	10541	assert_or_panic(v[57] == 2611);
	10542	assert_or_panic(v[58] == 2612);
	10543	assert_or_panic(v[59] == 2613);
	10544	assert_or_panic(v[60] == 2614);
	10545	assert_or_panic(v[61] == 2615);
	10546	assert_or_panic(v[62] == 2616);
	10547	assert_or_panic(v[63] == 2617);
	10548	assert_or_panic(v[64] == 2618);
	10549	assert_or_panic(v[65] == 2619);
	10550	assert_or_panic(v[66] == 2620);
	10551	assert_or_panic(v[67] == 2621);
	10552	assert_or_panic(v[68] == 2622);
	10553	assert_or_panic(v[69] == 2623);
	10554	assert_or_panic(v[70] == 2624);
	10555	assert_or_panic(v[71] == 2625);
	10556	assert_or_panic(v[72] == 2626);
	10557	assert_or_panic(v[73] == 2627);
	10558	assert_or_panic(v[74] == 2628);
	10559	assert_or_panic(v[75] == 2629);
	10560	assert_or_panic(v[76] == 2630);
	10561	assert_or_panic(v[77] == 2631);
	10562	assert_or_panic(v[78] == 2632);
	10563	assert_or_panic(v[79] == 2633);
	10564	assert_or_panic(v[80] == 2634);
	10565	assert_or_panic(v[81] == 2635);
	10566	assert_or_panic(v[82] == 2636);
	10567	assert_or_panic(v[83] == 2637);
	10568	assert_or_panic(v[84] == 2638);
	10569	assert_or_panic(v[85] == 2639);
	10570	assert_or_panic(v[86] == 2640);
	10571	assert_or_panic(v[87] == 2641);
	10572	assert_or_panic(v[88] == 2642);
	10573	assert_or_panic(v[89] == 2643);
	10574	assert_or_panic(v[90] == 2644);
	10575	assert_or_panic(v[91] == 2645);
	10576	assert_or_panic(v[92] == 2646);
	10577	assert_or_panic(v[93] == 2647);
	10578	assert_or_panic(v[94] == 2648);
	10579	assert_or_panic(v[95] == 2649);
	10580	assert_or_panic(v[96] == 2650);
	10581	assert_or_panic(v[97] == 2651);
	10582	assert_or_panic(v[98] == 2652);
	10583	assert_or_panic(v[99] == 2653);
	10584	assert_or_panic(v[100] == 2654);
	10585	assert_or_panic(v[101] == 2655);
	10586	assert_or_panic(v[102] == 2656);
	10587	assert_or_panic(v[103] == 2657);
	10588	assert_or_panic(v[104] == 2658);
	10589	assert_or_panic(v[105] == 2659);
	10590	assert_or_panic(v[106] == 2660);
	10591	assert_or_panic(v[107] == 2661);
	10592	assert_or_panic(v[108] == 2662);
	10593	assert_or_panic(v[109] == 2663);
	10594	assert_or_panic(v[110] == 2664);
	10595	assert_or_panic(v[111] == 2665);
	10596	assert_or_panic(v[112] == 2666);
	10597	assert_or_panic(v[113] == 2667);
	10598	assert_or_panic(v[114] == 2668);
	10599	assert_or_panic(v[115] == 2669);
	10600	assert_or_panic(v[116] == 2670);
	10601	assert_or_panic(v[117] == 2671);
	10602	assert_or_panic(v[118] == 2672);
	10603	assert_or_panic(v[119] == 2673);
	10604	assert_or_panic(v[120] == 2674);
	10605	assert_or_panic(v[121] == 2675);
	10606	assert_or_panic(v[122] == 2676);
	10607	assert_or_panic(v[123] == 2677);
	10608	assert_or_panic(v[124] == 2678);
	10609	assert_or_panic(v[125] == 2679);
	10610	assert_or_panic(v[126] == 2680);
	10611	assert_or_panic(v[127] == 2681);
	10612	assert_or_panic(v[128] == 2682);
	10613	assert_or_panic(v[129] == 2683);
	10614	assert_or_panic(v[130] == 2684);
	10615	assert_or_panic(v[131] == 2685);
	10616	assert_or_panic(v[132] == 2686);
	10617	assert_or_panic(v[133] == 2687);
	10618	assert_or_panic(v[134] == 2688);
	10619	assert_or_panic(v[135] == 2689);
	10620	assert_or_panic(v[136] == 2690);
	10621	assert_or_panic(v[137] == 2691);
	10622	assert_or_panic(v[138] == 2692);
	10623	assert_or_panic(v[139] == 2693);
	10624	assert_or_panic(v[140] == 2694);
	10625	assert_or_panic(v[141] == 2695);
	10626	assert_or_panic(v[142] == 2696);
	10627	assert_or_panic(v[143] == 2697);
	10628	assert_or_panic(v[144] == 2698);
	10629	assert_or_panic(v[145] == 2699);
	10630	assert_or_panic(v[146] == 2700);
	10631	assert_or_panic(v[147] == 2701);
	10632	assert_or_panic(v[148] == 2702);
	10633	assert_or_panic(v[149] == 2703);
	10634	assert_or_panic(v[150] == 2704);
	10635	assert_or_panic(v[151] == 2705);
	10636	assert_or_panic(v[152] == 2706);
	10637	assert_or_panic(v[153] == 2707);
	10638	assert_or_panic(v[154] == 2708);
	10639	assert_or_panic(v[155] == 2709);
	10640	assert_or_panic(v[156] == 2710);
	10641	assert_or_panic(v[157] == 2711);
	10642	assert_or_panic(v[158] == 2712);
	10643	assert_or_panic(v[159] == 2713);
	10644	assert_or_panic(v[160] == 2714);
	10645	assert_or_panic(v[161] == 2715);
	10646	assert_or_panic(v[162] == 2716);
	10647	assert_or_panic(v[163] == 2717);
	10648	assert_or_panic(v[164] == 2718);
	10649	assert_or_panic(v[165] == 2719);
	10650	assert_or_panic(v[166] == 2720);
	10651	assert_or_panic(v[167] == 2721);
	10652	assert_or_panic(v[168] == 2722);
	10653	assert_or_panic(v[169] == 2723);
	10654	assert_or_panic(v[170] == 2724);
	10655	assert_or_panic(v[171] == 2725);
	10656	assert_or_panic(v[172] == 2726);
	10657	assert_or_panic(v[173] == 2727);
	10658	assert_or_panic(v[174] == 2728);
	10659	assert_or_panic(v[175] == 2729);
	10660	assert_or_panic(v[176] == 2730);
	10661	assert_or_panic(v[177] == 2731);
	10662	assert_or_panic(v[178] == 2732);
	10663	assert_or_panic(v[179] == 2733);
	10664	assert_or_panic(v[180] == 2734);
	10665	assert_or_panic(v[181] == 2735);
	10666	assert_or_panic(v[182] == 2736);
	10667	assert_or_panic(v[183] == 2737);
	10668	assert_or_panic(v[184] == 2738);
	10669	assert_or_panic(v[185] == 2739);
	10670	assert_or_panic(v[186] == 2740);
	10671	assert_or_panic(v[187] == 2741);
	10672	assert_or_panic(v[188] == 2742);
	10673	assert_or_panic(v[189] == 2743);
	10674	assert_or_panic(v[190] == 2744);
	10675	assert_or_panic(v[191] == 2745);
	10676	assert_or_panic(v[192] == 2746);
	10677	assert_or_panic(v[193] == 2747);
	10678	assert_or_panic(v[194] == 2748);
	10679	assert_or_panic(v[195] == 2749);
	10680	assert_or_panic(v[196] == 2750);
	10681	assert_or_panic(v[197] == 2751);
	10682	assert_or_panic(v[198] == 2752);
	10683	assert_or_panic(v[199] == 2753);
	10684	assert_or_panic(v[200] == 2754);
	10685	assert_or_panic(v[201] == 2755);
	10686	assert_or_panic(v[202] == 2756);
	10687	assert_or_panic(v[203] == 2757);
	10688	assert_or_panic(v[204] == 2758);
	10689	assert_or_panic(v[205] == 2759);
	10690	assert_or_panic(v[206] == 2760);
	10691	assert_or_panic(v[207] == 2761);
	10692	assert_or_panic(v[208] == 2762);
	10693	assert_or_panic(v[209] == 2763);
	10694	assert_or_panic(v[210] == 2764);
	10695	assert_or_panic(v[211] == 2765);
	10696	assert_or_panic(v[212] == 2766);
	10697	assert_or_panic(v[213] == 2767);
	10698	assert_or_panic(v[214] == 2768);
	10699	assert_or_panic(v[215] == 2769);
	10700	assert_or_panic(v[216] == 2770);
	10701	assert_or_panic(v[217] == 2771);
	10702	assert_or_panic(v[218] == 2772);
	10703	assert_or_panic(v[219] == 2773);
	10704	assert_or_panic(v[220] == 2774);
	10705	assert_or_panic(v[221] == 2775);
	10706	assert_or_panic(v[222] == 2776);
	10707	assert_or_panic(v[223] == 2777);
	10708	assert_or_panic(v[224] == 2778);
	10709	assert_or_panic(v[225] == 2779);
	10710	assert_or_panic(v[226] == 2780);
	10711	assert_or_panic(v[227] == 2781);
	10712	assert_or_panic(v[228] == 2782);
	10713	assert_or_panic(v[229] == 2783);
	10714	assert_or_panic(v[230] == 2784);
	10715	assert_or_panic(v[231] == 2785);
	10716	assert_or_panic(v[232] == 2786);
	10717	assert_or_panic(v[233] == 2787);
	10718	assert_or_panic(v[234] == 2788);
	10719	assert_or_panic(v[235] == 2789);
	10720	assert_or_panic(v[236] == 2790);
	10721	assert_or_panic(v[237] == 2791);
	10722	assert_or_panic(v[238] == 2792);
	10723	assert_or_panic(v[239] == 2793);
	10724	assert_or_panic(v[240] == 2794);
	10725	assert_or_panic(v[241] == 2795);
	10726	assert_or_panic(v[242] == 2796);
	10727	assert_or_panic(v[243] == 2797);
	10728	assert_or_panic(v[244] == 2798);
	10729	assert_or_panic(v[245] == 2799);
	10730	assert_or_panic(v[246] == 2800);
	10731	assert_or_panic(v[247] == 2801);
	10732	assert_or_panic(v[248] == 2802);
	10733	assert_or_panic(v[249] == 2803);
	10734	assert_or_panic(v[250] == 2804);
	10735	assert_or_panic(v[251] == 2805);
	10736	assert_or_panic(v[252] == 2806);
	10737	assert_or_panic(v[253] == 2807);
	10738	assert_or_panic(v[254] == 2808);
	10739	assert_or_panic(v[255] == 2809);
	10740	zig_vector_256_u16((Vector_256_u16){
	10741	2810, 2811, 2812, 2813, 2814, 2815, 2816, 2817, 2818, 2819, 2820, 2821, 2822, 2823, 2824, 2825,
	10742	2826, 2827, 2828, 2829, 2830, 2831, 2832, 2833, 2834, 2835, 2836, 2837, 2838, 2839, 2840, 2841,
	10743	2842, 2843, 2844, 2845, 2846, 2847, 2848, 2849, 2850, 2851, 2852, 2853, 2854, 2855, 2856, 2857,
	10744	2858, 2859, 2860, 2861, 2862, 2863, 2864, 2865, 2866, 2867, 2868, 2869, 2870, 2871, 2872, 2873,
	10745	2874, 2875, 2876, 2877, 2878, 2879, 2880, 2881, 2882, 2883, 2884, 2885, 2886, 2887, 2888, 2889,
	10746	2890, 2891, 2892, 2893, 2894, 2895, 2896, 2897, 2898, 2899, 2900, 2901, 2902, 2903, 2904, 2905,
	10747	2906, 2907, 2908, 2909, 2910, 2911, 2912, 2913, 2914, 2915, 2916, 2917, 2918, 2919, 2920, 2921,
	10748	2922, 2923, 2924, 2925, 2926, 2927, 2928, 2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937,
	10749	2938, 2939, 2940, 2941, 2942, 2943, 2944, 2945, 2946, 2947, 2948, 2949, 2950, 2951, 2952, 2953,
	10750	2954, 2955, 2956, 2957, 2958, 2959, 2960, 2961, 2962, 2963, 2964, 2965, 2966, 2967, 2968, 2969,
	10751	2970, 2971, 2972, 2973, 2974, 2975, 2976, 2977, 2978, 2979, 2980, 2981, 2982, 2983, 2984, 2985,
	10752	2986, 2987, 2988, 2989, 2990, 2991, 2992, 2993, 2994, 2995, 2996, 2997, 2998, 2999, 3000, 3001,
	10753	3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017,
	10754	3018, 3019, 3020, 3021, 3022, 3023, 3024, 3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, 3033,
	10755	3034, 3035, 3036, 3037, 3038, 3039, 3040, 3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048, 3049,
	10756	3050, 3051, 3052, 3053, 3054, 3055, 3056, 3057, 3058, 3059, 3060, 3061, 3062, 3063, 3064, 3065,
	10757	}, 256);
	10758	}
	10759
	10760	typedef uint32_t Vector_1_u32 __attribute__((vector_size(1 * sizeof(uint32_t))));
	10761
	10762	Vector_1_u32 zig_ret_vector_1_u32(void);
	10763	void zig_vector_1_u32(Vector_1_u32, size_t);
	10764
	10765	Vector_1_u32 c_ret_vector_1_u32(void) {
	10766	return (Vector_1_u32){ 3 };
	10767	}
	10768	void c_vector_1_u32(Vector_1_u32 v, size_t i) {
	10769	assert_or_panic(v[0] == 4);
	10770	assert_or_panic(i == 1);
	10771	}
	10772	void c_test_vector_1_u32(void) {
	10773	Vector_1_u32 v = zig_ret_vector_1_u32();
	10774	assert_or_panic(v[0] == 1);
	10775	zig_vector_1_u32((Vector_1_u32){ 2 }, 1);
	10776	}
	10777
	10778	typedef uint32_t Vector_2_u32 __attribute__((vector_size(2 * sizeof(uint32_t))));
	10779
	10780	Vector_2_u32 zig_ret_vector_2_u32(void);
	10781	void zig_vector_2_u32(Vector_2_u32, size_t);
	10782
	10783	Vector_2_u32 c_ret_vector_2_u32(void) {
	10784	return (Vector_2_u32){ 9, 10 };
	10785	}
	10786	void c_vector_2_u32(Vector_2_u32 v, size_t i) {
	10787	assert_or_panic(v[0] == 11);
	10788	assert_or_panic(v[1] == 12);
	10789	assert_or_panic(i == 2);
	10790	}
	10791	void c_test_vector_2_u32(void) {
	10792	Vector_2_u32 v = zig_ret_vector_2_u32();
	10793	assert_or_panic(v[0] == 5);
	10794	assert_or_panic(v[1] == 6);
	10795	zig_vector_2_u32((Vector_2_u32){ 7, 8 }, 2);
	10796	}
	10797
	10798	typedef uint32_t Vector_3_u32 __attribute__((vector_size(3 * sizeof(uint32_t))));
	10799
	10800	Vector_3_u32 zig_ret_vector_3_u32(void);
	10801	void zig_vector_3_u32(Vector_3_u32, size_t);
	10802
	10803	Vector_3_u32 c_ret_vector_3_u32(void) {
	10804	return (Vector_3_u32){ 19, 20, 21 };
	10805	}
	10806	void c_vector_3_u32(Vector_3_u32 v, size_t i) {
	10807	assert_or_panic(v[0] == 22);
	10808	assert_or_panic(v[1] == 23);
	10809	assert_or_panic(v[2] == 24);
	10810	assert_or_panic(i == 3);
	10811	}
	10812	void c_test_vector_3_u32(void) {
	10813	Vector_3_u32 v = zig_ret_vector_3_u32();
	10814	assert_or_panic(v[0] == 13);
	10815	assert_or_panic(v[1] == 14);
	10816	assert_or_panic(v[2] == 15);
	10817	zig_vector_3_u32((Vector_3_u32){ 16, 17, 18 }, 3);
	10818	}
	10819
	10820	typedef uint32_t Vector_4_u32 __attribute__((vector_size(4 * sizeof(uint32_t))));
	10821
	10822	Vector_4_u32 zig_ret_vector_4_u32(void);
	10823
	10824	void zig_vector_4_u32(Vector_4_u32, size_t);
	10825	void zig_vector_4_u32_vector_4_u32(Vector_4_u32, Vector_4_u32, size_t);
	10826
	10827	Vector_4_u32 c_ret_vector_4_u32(void) {
	10828	return (Vector_4_u32){ 41, 42, 43, 44 };
	10829	}
	10830	void c_vector_4_u32(Vector_4_u32 v, size_t i) {
	10831	assert_or_panic(v[0] == 45);
	10832	assert_or_panic(v[1] == 46);
	10833	assert_or_panic(v[2] == 47);
	10834	assert_or_panic(v[3] == 48);
	10835	assert_or_panic(i == 4);
	10836	}
	10837	void c_vector_4_u32_vector_4_u32(Vector_4_u32 v0, Vector_4_u32 v1, size_t i) {
	10838	assert_or_panic(v0[0] == 49);
	10839	assert_or_panic(v0[1] == 50);
	10840	assert_or_panic(v0[2] == 51);
	10841	assert_or_panic(v0[3] == 52);
	10842	assert_or_panic(v1[0] == 53);
	10843	assert_or_panic(v1[1] == 54);
	10844	assert_or_panic(v1[2] == 55);
	10845	assert_or_panic(v1[3] == 56);
	10846	assert_or_panic(i == 8);
	10847	}
	10848	void c_test_vector_4_u32(void) {
	10849	Vector_4_u32 v = zig_ret_vector_4_u32();
	10850	assert_or_panic(v[0] == 25);
	10851	assert_or_panic(v[1] == 26);
	10852	assert_or_panic(v[2] == 27);
	10853	assert_or_panic(v[3] == 28);
	10854	zig_vector_4_u32((Vector_4_u32){ 29, 30, 31, 32 }, 4);
	10855	zig_vector_4_u32_vector_4_u32((Vector_4_u32){ 33, 34, 35, 36 }, (Vector_4_u32){ 37, 38, 39, 40 }, 8);
	10856	}
	10857
	10858	typedef uint32_t Vector_6_u32 __attribute__((vector_size(6 * sizeof(uint32_t))));
	10859
	10860	Vector_6_u32 zig_ret_vector_6_u32(void);
	10861	void zig_vector_6_u32(Vector_6_u32, size_t);
	10862
	10863	Vector_6_u32 c_ret_vector_6_u32(void) {
	10864	return (Vector_6_u32){ 53, 54, 55, 56, 57, 58 };
	10865	}
	10866	void c_vector_6_u32(Vector_6_u32 v, size_t i) {
	10867	assert_or_panic(v[0] == 59);
	10868	assert_or_panic(v[1] == 60);
	10869	assert_or_panic(v[2] == 61);
	10870	assert_or_panic(v[3] == 62);
	10871	assert_or_panic(v[4] == 63);
	10872	assert_or_panic(v[5] == 64);
	10873	assert_or_panic(i == 6);
	10874	}
	10875	void c_test_vector_6_u32(void) {
	10876	Vector_6_u32 v = zig_ret_vector_6_u32();
	10877	assert_or_panic(v[0] == 41);
	10878	assert_or_panic(v[1] == 42);
	10879	assert_or_panic(v[2] == 43);
	10880	assert_or_panic(v[3] == 44);
	10881	assert_or_panic(v[4] == 45);
	10882	assert_or_panic(v[5] == 46);
	10883	zig_vector_6_u32((Vector_6_u32){ 47, 48, 49, 50, 51, 52 }, 6);
	10884	}
	10885
	10886	typedef uint32_t Vector_8_u32 __attribute__((vector_size(8 * sizeof(uint32_t))));
	10887
	10888	Vector_8_u32 zig_ret_vector_8_u32(void);
	10889	void zig_vector_8_u32(Vector_8_u32, size_t);
	10890
	10891	Vector_8_u32 c_ret_vector_8_u32(void) {
	10892	return (Vector_8_u32){ 81, 82, 83, 84, 85, 86, 87, 88 };
	10893	}
	10894	void c_vector_8_u32(Vector_8_u32 v, size_t i) {
	10895	assert_or_panic(v[0] == 89);
	10896	assert_or_panic(v[1] == 90);
	10897	assert_or_panic(v[2] == 91);
	10898	assert_or_panic(v[3] == 92);
	10899	assert_or_panic(v[4] == 93);
	10900	assert_or_panic(v[5] == 94);
	10901	assert_or_panic(v[6] == 95);
	10902	assert_or_panic(v[7] == 96);
	10903	assert_or_panic(i == 8);
	10904	}
	10905	void c_test_vector_8_u32(void) {
	10906	Vector_8_u32 v = zig_ret_vector_8_u32();
	10907	assert_or_panic(v[0] == 65);
	10908	assert_or_panic(v[1] == 66);
	10909	assert_or_panic(v[2] == 67);
	10910	assert_or_panic(v[3] == 68);
	10911	assert_or_panic(v[4] == 69);
	10912	assert_or_panic(v[5] == 70);
	10913	assert_or_panic(v[6] == 71);
	10914	assert_or_panic(v[7] == 72);
	10915	zig_vector_8_u32((Vector_8_u32){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8);
	10916	}
	10917
	10918	typedef uint32_t Vector_12_u32 __attribute__((vector_size(12 * sizeof(uint32_t))));
	10919
	10920	Vector_12_u32 zig_ret_vector_12_u32(void);
	10921	void zig_vector_12_u32(Vector_12_u32, size_t);
	10922
	10923	Vector_12_u32 c_ret_vector_12_u32(void) {
	10924	return (Vector_12_u32){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 };
	10925	}
	10926	void c_vector_12_u32(Vector_12_u32 v, size_t i) {
	10927	assert_or_panic(v[0] == 133);
	10928	assert_or_panic(v[1] == 134);
	10929	assert_or_panic(v[2] == 135);
	10930	assert_or_panic(v[3] == 136);
	10931	assert_or_panic(v[4] == 137);
	10932	assert_or_panic(v[5] == 138);
	10933	assert_or_panic(v[6] == 139);
	10934	assert_or_panic(v[7] == 140);
	10935	assert_or_panic(v[8] == 141);
	10936	assert_or_panic(v[9] == 142);
	10937	assert_or_panic(v[10] == 143);
	10938	assert_or_panic(v[11] == 144);
	10939	assert_or_panic(i == 12);
	10940	}
	10941	void c_test_vector_12_u32(void) {
	10942	Vector_12_u32 v = zig_ret_vector_12_u32();
	10943	assert_or_panic(v[0] == 97);
	10944	assert_or_panic(v[1] == 98);
	10945	assert_or_panic(v[2] == 99);
	10946	assert_or_panic(v[3] == 100);
	10947	assert_or_panic(v[4] == 101);
	10948	assert_or_panic(v[5] == 102);
	10949	assert_or_panic(v[6] == 103);
	10950	assert_or_panic(v[7] == 104);
	10951	assert_or_panic(v[8] == 105);
	10952	assert_or_panic(v[9] == 106);
	10953	assert_or_panic(v[10] == 107);
	10954	assert_or_panic(v[11] == 108);
	10955	zig_vector_12_u32((Vector_12_u32){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12);
	10956	}
	10957
	10958	typedef uint32_t Vector_16_u32 __attribute__((vector_size(16 * sizeof(uint32_t))));
	10959
	10960	Vector_16_u32 zig_ret_vector_16_u32(void);
	10961	void zig_vector_16_u32(Vector_16_u32, size_t);
	10962
	10963	Vector_16_u32 c_ret_vector_16_u32(void) {
	10964	return (Vector_16_u32){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 };
	10965	}
	10966	void c_vector_16_u32(Vector_16_u32 v, size_t i) {
	10967	assert_or_panic(v[0] == 193);
	10968	assert_or_panic(v[1] == 194);
	10969	assert_or_panic(v[2] == 195);
	10970	assert_or_panic(v[3] == 196);
	10971	assert_or_panic(v[4] == 197);
	10972	assert_or_panic(v[5] == 198);
	10973	assert_or_panic(v[6] == 199);
	10974	assert_or_panic(v[7] == 200);
	10975	assert_or_panic(v[8] == 201);
	10976	assert_or_panic(v[9] == 202);
	10977	assert_or_panic(v[10] == 203);
	10978	assert_or_panic(v[11] == 204);
	10979	assert_or_panic(v[12] == 205);
	10980	assert_or_panic(v[13] == 206);
	10981	assert_or_panic(v[14] == 207);
	10982	assert_or_panic(v[15] == 208);
	10983	assert_or_panic(i == 16);
	10984	}
	10985	void c_test_vector_16_u32(void) {
	10986	Vector_16_u32 v = zig_ret_vector_16_u32();
	10987	assert_or_panic(v[0] == 145);
	10988	assert_or_panic(v[1] == 146);
	10989	assert_or_panic(v[2] == 147);
	10990	assert_or_panic(v[3] == 148);
	10991	assert_or_panic(v[4] == 149);
	10992	assert_or_panic(v[5] == 150);
	10993	assert_or_panic(v[6] == 151);
	10994	assert_or_panic(v[7] == 152);
	10995	assert_or_panic(v[8] == 153);
	10996	assert_or_panic(v[9] == 154);
	10997	assert_or_panic(v[10] == 155);
	10998	assert_or_panic(v[11] == 156);
	10999	assert_or_panic(v[12] == 157);
	11000	assert_or_panic(v[13] == 158);
	11001	assert_or_panic(v[14] == 159);
	11002	assert_or_panic(v[15] == 160);
	11003	zig_vector_16_u32((Vector_16_u32){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16);
	11004	}
	11005
	11006	typedef uint32_t Vector_24_u32 __attribute__((vector_size(24 * sizeof(uint32_t))));
	11007
	11008	Vector_24_u32 zig_ret_vector_24_u32(void);
	11009	void zig_vector_24_u32(Vector_24_u32, size_t);
	11010
	11011	Vector_24_u32 c_ret_vector_24_u32(void) {
	11012	return (Vector_24_u32){
	11013	257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
	11014	273, 274, 275, 276, 277, 278, 279, 280,
	11015	};
	11016	}
	11017	void c_vector_24_u32(Vector_24_u32 v, size_t i) {
	11018	assert_or_panic(v[0] == 281);
	11019	assert_or_panic(v[1] == 282);
	11020	assert_or_panic(v[2] == 283);
	11021	assert_or_panic(v[3] == 284);
	11022	assert_or_panic(v[4] == 285);
	11023	assert_or_panic(v[5] == 286);
	11024	assert_or_panic(v[6] == 287);
	11025	assert_or_panic(v[7] == 288);
	11026	assert_or_panic(v[8] == 289);
	11027	assert_or_panic(v[9] == 290);
	11028	assert_or_panic(v[10] == 291);
	11029	assert_or_panic(v[11] == 292);
	11030	assert_or_panic(v[12] == 293);
	11031	assert_or_panic(v[13] == 294);
	11032	assert_or_panic(v[14] == 295);
	11033	assert_or_panic(v[15] == 296);
	11034	assert_or_panic(v[16] == 297);
	11035	assert_or_panic(v[17] == 298);
	11036	assert_or_panic(v[18] == 299);
	11037	assert_or_panic(v[19] == 300);
	11038	assert_or_panic(v[20] == 301);
	11039	assert_or_panic(v[21] == 302);
	11040	assert_or_panic(v[22] == 303);
	11041	assert_or_panic(v[23] == 304);
	11042	assert_or_panic(i == 24);
	11043	}
	11044	void c_test_vector_24_u32(void) {
	11045	Vector_24_u32 v = zig_ret_vector_24_u32();
	11046	assert_or_panic(v[0] == 209);
	11047	assert_or_panic(v[1] == 210);
	11048	assert_or_panic(v[2] == 211);
	11049	assert_or_panic(v[3] == 212);
	11050	assert_or_panic(v[4] == 213);
	11051	assert_or_panic(v[5] == 214);
	11052	assert_or_panic(v[6] == 215);
	11053	assert_or_panic(v[7] == 216);
	11054	assert_or_panic(v[8] == 217);
	11055	assert_or_panic(v[9] == 218);
	11056	assert_or_panic(v[10] == 219);
	11057	assert_or_panic(v[11] == 220);
	11058	assert_or_panic(v[12] == 221);
	11059	assert_or_panic(v[13] == 222);
	11060	assert_or_panic(v[14] == 223);
	11061	assert_or_panic(v[15] == 224);
	11062	assert_or_panic(v[16] == 225);
	11063	assert_or_panic(v[17] == 226);
	11064	assert_or_panic(v[18] == 227);
	11065	assert_or_panic(v[19] == 228);
	11066	assert_or_panic(v[20] == 229);
	11067	assert_or_panic(v[21] == 230);
	11068	assert_or_panic(v[22] == 231);
	11069	assert_or_panic(v[23] == 232);
	11070	zig_vector_24_u32((Vector_24_u32){
	11071	233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
	11072	249, 250, 251, 252, 253, 254, 255, 256,
	11073	}, 24);
	11074	}
	11075
	11076	typedef uint32_t Vector_32_u32 __attribute__((vector_size(32 * sizeof(uint32_t))));
	11077
	11078	Vector_32_u32 zig_ret_vector_32_u32(void);
	11079	void zig_vector_32_u32(Vector_32_u32, size_t);
	11080
	11081	Vector_32_u32 c_ret_vector_32_u32(void) {
	11082	return (Vector_32_u32){
	11083	369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
	11084	385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400,
	11085	};
	11086	}
	11087	void c_vector_32_u32(Vector_32_u32 v, size_t i) {
	11088	assert_or_panic(v[0] == 401);
	11089	assert_or_panic(v[1] == 402);
	11090	assert_or_panic(v[2] == 403);
	11091	assert_or_panic(v[3] == 404);
	11092	assert_or_panic(v[4] == 405);
	11093	assert_or_panic(v[5] == 406);
	11094	assert_or_panic(v[6] == 407);
	11095	assert_or_panic(v[7] == 408);
	11096	assert_or_panic(v[8] == 409);
	11097	assert_or_panic(v[9] == 410);
	11098	assert_or_panic(v[10] == 411);
	11099	assert_or_panic(v[11] == 412);
	11100	assert_or_panic(v[12] == 413);
	11101	assert_or_panic(v[13] == 414);
	11102	assert_or_panic(v[14] == 415);
	11103	assert_or_panic(v[15] == 416);
	11104	assert_or_panic(v[16] == 417);
	11105	assert_or_panic(v[17] == 418);
	11106	assert_or_panic(v[18] == 419);
	11107	assert_or_panic(v[19] == 420);
	11108	assert_or_panic(v[20] == 421);
	11109	assert_or_panic(v[21] == 422);
	11110	assert_or_panic(v[22] == 423);
	11111	assert_or_panic(v[23] == 424);
	11112	assert_or_panic(v[24] == 425);
	11113	assert_or_panic(v[25] == 426);
	11114	assert_or_panic(v[26] == 427);
	11115	assert_or_panic(v[27] == 428);
	11116	assert_or_panic(v[28] == 429);
	11117	assert_or_panic(v[29] == 430);
	11118	assert_or_panic(v[30] == 431);
	11119	assert_or_panic(v[31] == 432);
	11120	assert_or_panic(i == 32);
	11121	}
	11122	void c_test_vector_32_u32(void) {
	11123	Vector_32_u32 v = zig_ret_vector_32_u32();
	11124	assert_or_panic(v[0] == 305);
	11125	assert_or_panic(v[1] == 306);
	11126	assert_or_panic(v[2] == 307);
	11127	assert_or_panic(v[3] == 308);
	11128	assert_or_panic(v[4] == 309);
	11129	assert_or_panic(v[5] == 310);
	11130	assert_or_panic(v[6] == 311);
	11131	assert_or_panic(v[7] == 312);
	11132	assert_or_panic(v[8] == 313);
	11133	assert_or_panic(v[9] == 314);
	11134	assert_or_panic(v[10] == 315);
	11135	assert_or_panic(v[11] == 316);
	11136	assert_or_panic(v[12] == 317);
	11137	assert_or_panic(v[13] == 318);
	11138	assert_or_panic(v[14] == 319);
	11139	assert_or_panic(v[15] == 320);
	11140	assert_or_panic(v[16] == 321);
	11141	assert_or_panic(v[17] == 322);
	11142	assert_or_panic(v[18] == 323);
	11143	assert_or_panic(v[19] == 324);
	11144	assert_or_panic(v[20] == 325);
	11145	assert_or_panic(v[21] == 326);
	11146	assert_or_panic(v[22] == 327);
	11147	assert_or_panic(v[23] == 328);
	11148	assert_or_panic(v[24] == 329);
	11149	assert_or_panic(v[25] == 330);
	11150	assert_or_panic(v[26] == 331);
	11151	assert_or_panic(v[27] == 332);
	11152	assert_or_panic(v[28] == 333);
	11153	assert_or_panic(v[29] == 334);
	11154	assert_or_panic(v[30] == 335);
	11155	assert_or_panic(v[31] == 336);
	11156	zig_vector_32_u32((Vector_32_u32){
	11157	337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
	11158	353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
	11159	}, 32);
	11160	}
	11161
	11162	typedef uint32_t Vector_48_u32 __attribute__((vector_size(48 * sizeof(uint32_t))));
	11163
	11164	Vector_48_u32 zig_ret_vector_48_u32(void);
	11165	void zig_vector_48_u32(Vector_48_u32, size_t);
	11166
	11167	Vector_48_u32 c_ret_vector_48_u32(void) {
	11168	return (Vector_48_u32){
	11169	529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544,
	11170	545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560,
	11171	561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576,
	11172	};
	11173	}
	11174	void c_vector_48_u32(Vector_48_u32 v, size_t i) {
	11175	assert_or_panic(v[0] == 577);
	11176	assert_or_panic(v[1] == 578);
	11177	assert_or_panic(v[2] == 579);
	11178	assert_or_panic(v[3] == 580);
	11179	assert_or_panic(v[4] == 581);
	11180	assert_or_panic(v[5] == 582);
	11181	assert_or_panic(v[6] == 583);
	11182	assert_or_panic(v[7] == 584);
	11183	assert_or_panic(v[8] == 585);
	11184	assert_or_panic(v[9] == 586);
	11185	assert_or_panic(v[10] == 587);
	11186	assert_or_panic(v[11] == 588);
	11187	assert_or_panic(v[12] == 589);
	11188	assert_or_panic(v[13] == 590);
	11189	assert_or_panic(v[14] == 591);
	11190	assert_or_panic(v[15] == 592);
	11191	assert_or_panic(v[16] == 593);
	11192	assert_or_panic(v[17] == 594);
	11193	assert_or_panic(v[18] == 595);
	11194	assert_or_panic(v[19] == 596);
	11195	assert_or_panic(v[20] == 597);
	11196	assert_or_panic(v[21] == 598);
	11197	assert_or_panic(v[22] == 599);
	11198	assert_or_panic(v[23] == 600);
	11199	assert_or_panic(v[24] == 601);
	11200	assert_or_panic(v[25] == 602);
	11201	assert_or_panic(v[26] == 603);
	11202	assert_or_panic(v[27] == 604);
	11203	assert_or_panic(v[28] == 605);
	11204	assert_or_panic(v[29] == 606);
	11205	assert_or_panic(v[30] == 607);
	11206	assert_or_panic(v[31] == 608);
	11207	assert_or_panic(v[32] == 609);
	11208	assert_or_panic(v[33] == 610);
	11209	assert_or_panic(v[34] == 611);
	11210	assert_or_panic(v[35] == 612);
	11211	assert_or_panic(v[36] == 613);
	11212	assert_or_panic(v[37] == 614);
	11213	assert_or_panic(v[38] == 615);
	11214	assert_or_panic(v[39] == 616);
	11215	assert_or_panic(v[40] == 617);
	11216	assert_or_panic(v[41] == 618);
	11217	assert_or_panic(v[42] == 619);
	11218	assert_or_panic(v[43] == 620);
	11219	assert_or_panic(v[44] == 621);
	11220	assert_or_panic(v[45] == 622);
	11221	assert_or_panic(v[46] == 623);
	11222	assert_or_panic(v[47] == 624);
	11223	assert_or_panic(i == 48);
	11224	}
	11225	void c_test_vector_48_u32(void) {
	11226	Vector_48_u32 v = zig_ret_vector_48_u32();
	11227	assert_or_panic(v[0] == 433);
	11228	assert_or_panic(v[1] == 434);
	11229	assert_or_panic(v[2] == 435);
	11230	assert_or_panic(v[3] == 436);
	11231	assert_or_panic(v[4] == 437);
	11232	assert_or_panic(v[5] == 438);
	11233	assert_or_panic(v[6] == 439);
	11234	assert_or_panic(v[7] == 440);
	11235	assert_or_panic(v[8] == 441);
	11236	assert_or_panic(v[9] == 442);
	11237	assert_or_panic(v[10] == 443);
	11238	assert_or_panic(v[11] == 444);
	11239	assert_or_panic(v[12] == 445);
	11240	assert_or_panic(v[13] == 446);
	11241	assert_or_panic(v[14] == 447);
	11242	assert_or_panic(v[15] == 448);
	11243	assert_or_panic(v[16] == 449);
	11244	assert_or_panic(v[17] == 450);
	11245	assert_or_panic(v[18] == 451);
	11246	assert_or_panic(v[19] == 452);
	11247	assert_or_panic(v[20] == 453);
	11248	assert_or_panic(v[21] == 454);
	11249	assert_or_panic(v[22] == 455);
	11250	assert_or_panic(v[23] == 456);
	11251	assert_or_panic(v[24] == 457);
	11252	assert_or_panic(v[25] == 458);
	11253	assert_or_panic(v[26] == 459);
	11254	assert_or_panic(v[27] == 460);
	11255	assert_or_panic(v[28] == 461);
	11256	assert_or_panic(v[29] == 462);
	11257	assert_or_panic(v[30] == 463);
	11258	assert_or_panic(v[31] == 464);
	11259	assert_or_panic(v[32] == 465);
	11260	assert_or_panic(v[33] == 466);
	11261	assert_or_panic(v[34] == 467);
	11262	assert_or_panic(v[35] == 468);
	11263	assert_or_panic(v[36] == 469);
	11264	assert_or_panic(v[37] == 470);
	11265	assert_or_panic(v[38] == 471);
	11266	assert_or_panic(v[39] == 472);
	11267	assert_or_panic(v[40] == 473);
	11268	assert_or_panic(v[41] == 474);
	11269	assert_or_panic(v[42] == 475);
	11270	assert_or_panic(v[43] == 476);
	11271	assert_or_panic(v[44] == 477);
	11272	assert_or_panic(v[45] == 478);
	11273	assert_or_panic(v[46] == 479);
	11274	assert_or_panic(v[47] == 480);
	11275	zig_vector_48_u32((Vector_48_u32){
	11276	481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496,
	11277	497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
	11278	513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
	11279	}, 48);
	11280	}
	11281
	11282	typedef uint32_t Vector_64_u32 __attribute__((vector_size(64 * sizeof(uint32_t))));
	11283
	11284	Vector_64_u32 zig_ret_vector_64_u32(void);
	11285	void zig_vector_64_u32(Vector_64_u32, size_t);
	11286
	11287	Vector_64_u32 c_ret_vector_64_u32(void) {
	11288	return (Vector_64_u32){
	11289	753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768,
	11290	769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784,
	11291	785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800,
	11292	801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816,
	11293	};
	11294	}
	11295	void c_vector_64_u32(Vector_64_u32 v, size_t i) {
	11296	assert_or_panic(v[0] == 817);
	11297	assert_or_panic(v[1] == 818);
	11298	assert_or_panic(v[2] == 819);
	11299	assert_or_panic(v[3] == 820);
	11300	assert_or_panic(v[4] == 821);
	11301	assert_or_panic(v[5] == 822);
	11302	assert_or_panic(v[6] == 823);
	11303	assert_or_panic(v[7] == 824);
	11304	assert_or_panic(v[8] == 825);
	11305	assert_or_panic(v[9] == 826);
	11306	assert_or_panic(v[10] == 827);
	11307	assert_or_panic(v[11] == 828);
	11308	assert_or_panic(v[12] == 829);
	11309	assert_or_panic(v[13] == 830);
	11310	assert_or_panic(v[14] == 831);
	11311	assert_or_panic(v[15] == 832);
	11312	assert_or_panic(v[16] == 833);
	11313	assert_or_panic(v[17] == 834);
	11314	assert_or_panic(v[18] == 835);
	11315	assert_or_panic(v[19] == 836);
	11316	assert_or_panic(v[20] == 837);
	11317	assert_or_panic(v[21] == 838);
	11318	assert_or_panic(v[22] == 839);
	11319	assert_or_panic(v[23] == 840);
	11320	assert_or_panic(v[24] == 841);
	11321	assert_or_panic(v[25] == 842);
	11322	assert_or_panic(v[26] == 843);
	11323	assert_or_panic(v[27] == 844);
	11324	assert_or_panic(v[28] == 845);
	11325	assert_or_panic(v[29] == 846);
	11326	assert_or_panic(v[30] == 847);
	11327	assert_or_panic(v[31] == 848);
	11328	assert_or_panic(v[32] == 849);
	11329	assert_or_panic(v[33] == 850);
	11330	assert_or_panic(v[34] == 851);
	11331	assert_or_panic(v[35] == 852);
	11332	assert_or_panic(v[36] == 853);
	11333	assert_or_panic(v[37] == 854);
	11334	assert_or_panic(v[38] == 855);
	11335	assert_or_panic(v[39] == 856);
	11336	assert_or_panic(v[40] == 857);
	11337	assert_or_panic(v[41] == 858);
	11338	assert_or_panic(v[42] == 859);
	11339	assert_or_panic(v[43] == 860);
	11340	assert_or_panic(v[44] == 861);
	11341	assert_or_panic(v[45] == 862);
	11342	assert_or_panic(v[46] == 863);
	11343	assert_or_panic(v[47] == 864);
	11344	assert_or_panic(v[48] == 865);
	11345	assert_or_panic(v[49] == 866);
	11346	assert_or_panic(v[50] == 867);
	11347	assert_or_panic(v[51] == 868);
	11348	assert_or_panic(v[52] == 869);
	11349	assert_or_panic(v[53] == 870);
	11350	assert_or_panic(v[54] == 871);
	11351	assert_or_panic(v[55] == 872);
	11352	assert_or_panic(v[56] == 873);
	11353	assert_or_panic(v[57] == 874);
	11354	assert_or_panic(v[58] == 875);
	11355	assert_or_panic(v[59] == 876);
	11356	assert_or_panic(v[60] == 877);
	11357	assert_or_panic(v[61] == 878);
	11358	assert_or_panic(v[62] == 879);
	11359	assert_or_panic(v[63] == 880);
	11360	assert_or_panic(i == 64);
	11361	}
	11362	void c_test_vector_64_u32(void) {
	11363	Vector_64_u32 v = zig_ret_vector_64_u32();
	11364	assert_or_panic(v[0] == 625);
	11365	assert_or_panic(v[1] == 626);
	11366	assert_or_panic(v[2] == 627);
	11367	assert_or_panic(v[3] == 628);
	11368	assert_or_panic(v[4] == 629);
	11369	assert_or_panic(v[5] == 630);
	11370	assert_or_panic(v[6] == 631);
	11371	assert_or_panic(v[7] == 632);
	11372	assert_or_panic(v[8] == 633);
	11373	assert_or_panic(v[9] == 634);
	11374	assert_or_panic(v[10] == 635);
	11375	assert_or_panic(v[11] == 636);
	11376	assert_or_panic(v[12] == 637);
	11377	assert_or_panic(v[13] == 638);
	11378	assert_or_panic(v[14] == 639);
	11379	assert_or_panic(v[15] == 640);
	11380	assert_or_panic(v[16] == 641);
	11381	assert_or_panic(v[17] == 642);
	11382	assert_or_panic(v[18] == 643);
	11383	assert_or_panic(v[19] == 644);
	11384	assert_or_panic(v[20] == 645);
	11385	assert_or_panic(v[21] == 646);
	11386	assert_or_panic(v[22] == 647);
	11387	assert_or_panic(v[23] == 648);
	11388	assert_or_panic(v[24] == 649);
	11389	assert_or_panic(v[25] == 650);
	11390	assert_or_panic(v[26] == 651);
	11391	assert_or_panic(v[27] == 652);
	11392	assert_or_panic(v[28] == 653);
	11393	assert_or_panic(v[29] == 654);
	11394	assert_or_panic(v[30] == 655);
	11395	assert_or_panic(v[31] == 656);
	11396	assert_or_panic(v[32] == 657);
	11397	assert_or_panic(v[33] == 658);
	11398	assert_or_panic(v[34] == 659);
	11399	assert_or_panic(v[35] == 660);
	11400	assert_or_panic(v[36] == 661);
	11401	assert_or_panic(v[37] == 662);
	11402	assert_or_panic(v[38] == 663);
	11403	assert_or_panic(v[39] == 664);
	11404	assert_or_panic(v[40] == 665);
	11405	assert_or_panic(v[41] == 666);
	11406	assert_or_panic(v[42] == 667);
	11407	assert_or_panic(v[43] == 668);
	11408	assert_or_panic(v[44] == 669);
	11409	assert_or_panic(v[45] == 670);
	11410	assert_or_panic(v[46] == 671);
	11411	assert_or_panic(v[47] == 672);
	11412	assert_or_panic(v[48] == 673);
	11413	assert_or_panic(v[49] == 674);
	11414	assert_or_panic(v[50] == 675);
	11415	assert_or_panic(v[51] == 676);
	11416	assert_or_panic(v[52] == 677);
	11417	assert_or_panic(v[53] == 678);
	11418	assert_or_panic(v[54] == 679);
	11419	assert_or_panic(v[55] == 680);
	11420	assert_or_panic(v[56] == 681);
	11421	assert_or_panic(v[57] == 682);
	11422	assert_or_panic(v[58] == 683);
	11423	assert_or_panic(v[59] == 684);
	11424	assert_or_panic(v[60] == 685);
	11425	assert_or_panic(v[61] == 686);
	11426	assert_or_panic(v[62] == 687);
	11427	assert_or_panic(v[63] == 688);
	11428	zig_vector_64_u32((Vector_64_u32){
	11429	689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704,
	11430	705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720,
	11431	721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736,
	11432	737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752,
	11433	}, 64);
	11434	}
	11435
	11436	typedef uint32_t Vector_96_u32 __attribute__((vector_size(96 * sizeof(uint32_t))));
	11437
	11438	Vector_96_u32 zig_ret_vector_96_u32(void);
	11439	void zig_vector_96_u32(Vector_96_u32, size_t);
	11440
	11441	Vector_96_u32 c_ret_vector_96_u32(void) {
	11442	return (Vector_96_u32){
	11443	1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097,
	11444	1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113,
	11445	1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129,
	11446	1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145,
	11447	1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161,
	11448	1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177,
	11449	};
	11450	}
	11451	void c_vector_96_u32(Vector_96_u32 v, size_t i) {
	11452	assert_or_panic(v[0] == 1178);
	11453	assert_or_panic(v[1] == 1179);
	11454	assert_or_panic(v[2] == 1180);
	11455	assert_or_panic(v[3] == 1181);
	11456	assert_or_panic(v[4] == 1182);
	11457	assert_or_panic(v[5] == 1183);
	11458	assert_or_panic(v[6] == 1184);
	11459	assert_or_panic(v[7] == 1185);
	11460	assert_or_panic(v[8] == 1186);
	11461	assert_or_panic(v[9] == 1187);
	11462	assert_or_panic(v[10] == 1188);
	11463	assert_or_panic(v[11] == 1189);
	11464	assert_or_panic(v[12] == 1190);
	11465	assert_or_panic(v[13] == 1191);
	11466	assert_or_panic(v[14] == 1192);
	11467	assert_or_panic(v[15] == 1193);
	11468	assert_or_panic(v[16] == 1194);
	11469	assert_or_panic(v[17] == 1195);
	11470	assert_or_panic(v[18] == 1196);
	11471	assert_or_panic(v[19] == 1197);
	11472	assert_or_panic(v[20] == 1198);
	11473	assert_or_panic(v[21] == 1199);
	11474	assert_or_panic(v[22] == 1200);
	11475	assert_or_panic(v[23] == 1201);
	11476	assert_or_panic(v[24] == 1202);
	11477	assert_or_panic(v[25] == 1203);
	11478	assert_or_panic(v[26] == 1204);
	11479	assert_or_panic(v[27] == 1205);
	11480	assert_or_panic(v[28] == 1206);
	11481	assert_or_panic(v[29] == 1207);
	11482	assert_or_panic(v[30] == 1208);
	11483	assert_or_panic(v[31] == 1209);
	11484	assert_or_panic(v[32] == 1210);
	11485	assert_or_panic(v[33] == 1211);
	11486	assert_or_panic(v[34] == 1212);
	11487	assert_or_panic(v[35] == 1213);
	11488	assert_or_panic(v[36] == 1214);
	11489	assert_or_panic(v[37] == 1215);
	11490	assert_or_panic(v[38] == 1216);
	11491	assert_or_panic(v[39] == 1217);
	11492	assert_or_panic(v[40] == 1218);
	11493	assert_or_panic(v[41] == 1219);
	11494	assert_or_panic(v[42] == 1220);
	11495	assert_or_panic(v[43] == 1221);
	11496	assert_or_panic(v[44] == 1222);
	11497	assert_or_panic(v[45] == 1223);
	11498	assert_or_panic(v[46] == 1224);
	11499	assert_or_panic(v[47] == 1225);
	11500	assert_or_panic(v[48] == 1226);
	11501	assert_or_panic(v[49] == 1227);
	11502	assert_or_panic(v[50] == 1228);
	11503	assert_or_panic(v[51] == 1229);
	11504	assert_or_panic(v[52] == 1230);
	11505	assert_or_panic(v[53] == 1231);
	11506	assert_or_panic(v[54] == 1232);
	11507	assert_or_panic(v[55] == 1233);
	11508	assert_or_panic(v[56] == 1234);
	11509	assert_or_panic(v[57] == 1235);
	11510	assert_or_panic(v[58] == 1236);
	11511	assert_or_panic(v[59] == 1237);
	11512	assert_or_panic(v[60] == 1238);
	11513	assert_or_panic(v[61] == 1239);
	11514	assert_or_panic(v[62] == 1240);
	11515	assert_or_panic(v[63] == 1241);
	11516	assert_or_panic(v[64] == 1242);
	11517	assert_or_panic(v[65] == 1243);
	11518	assert_or_panic(v[66] == 1244);
	11519	assert_or_panic(v[67] == 1245);
	11520	assert_or_panic(v[68] == 1246);
	11521	assert_or_panic(v[69] == 1247);
	11522	assert_or_panic(v[70] == 1248);
	11523	assert_or_panic(v[71] == 1249);
	11524	assert_or_panic(v[72] == 1250);
	11525	assert_or_panic(v[73] == 1251);
	11526	assert_or_panic(v[74] == 1252);
	11527	assert_or_panic(v[75] == 1253);
	11528	assert_or_panic(v[76] == 1254);
	11529	assert_or_panic(v[77] == 1255);
	11530	assert_or_panic(v[80] == 1258);
	11531	assert_or_panic(v[81] == 1259);
	11532	assert_or_panic(v[82] == 1260);
	11533	assert_or_panic(v[83] == 1261);
	11534	assert_or_panic(v[84] == 1262);
	11535	assert_or_panic(v[85] == 1263);
	11536	assert_or_panic(v[86] == 1264);
	11537	assert_or_panic(v[87] == 1265);
	11538	assert_or_panic(v[88] == 1266);
	11539	assert_or_panic(v[89] == 1267);
	11540	assert_or_panic(v[90] == 1268);
	11541	assert_or_panic(v[91] == 1269);
	11542	assert_or_panic(v[92] == 1270);
	11543	assert_or_panic(v[93] == 1271);
	11544	assert_or_panic(v[94] == 1272);
	11545	assert_or_panic(v[95] == 1273);
	11546	assert_or_panic(i == 96);
	11547	}
	11548	void c_test_vector_96_u32(void) {
	11549	Vector_96_u32 v = zig_ret_vector_96_u32();
	11550	assert_or_panic(v[0] == 890);
	11551	assert_or_panic(v[1] == 891);
	11552	assert_or_panic(v[2] == 892);
	11553	assert_or_panic(v[3] == 893);
	11554	assert_or_panic(v[4] == 894);
	11555	assert_or_panic(v[5] == 895);
	11556	assert_or_panic(v[6] == 896);
	11557	assert_or_panic(v[7] == 897);
	11558	assert_or_panic(v[8] == 898);
	11559	assert_or_panic(v[9] == 899);
	11560	assert_or_panic(v[10] == 900);
	11561	assert_or_panic(v[11] == 901);
	11562	assert_or_panic(v[12] == 902);
	11563	assert_or_panic(v[13] == 903);
	11564	assert_or_panic(v[14] == 904);
	11565	assert_or_panic(v[15] == 905);
	11566	assert_or_panic(v[16] == 906);
	11567	assert_or_panic(v[17] == 907);
	11568	assert_or_panic(v[18] == 908);
	11569	assert_or_panic(v[19] == 909);
	11570	assert_or_panic(v[20] == 910);
	11571	assert_or_panic(v[21] == 911);
	11572	assert_or_panic(v[22] == 912);
	11573	assert_or_panic(v[23] == 913);
	11574	assert_or_panic(v[24] == 914);
	11575	assert_or_panic(v[25] == 915);
	11576	assert_or_panic(v[26] == 916);
	11577	assert_or_panic(v[27] == 917);
	11578	assert_or_panic(v[28] == 918);
	11579	assert_or_panic(v[29] == 919);
	11580	assert_or_panic(v[30] == 920);
	11581	assert_or_panic(v[31] == 921);
	11582	assert_or_panic(v[32] == 922);
	11583	assert_or_panic(v[33] == 923);
	11584	assert_or_panic(v[34] == 924);
	11585	assert_or_panic(v[35] == 925);
	11586	assert_or_panic(v[36] == 926);
	11587	assert_or_panic(v[37] == 927);
	11588	assert_or_panic(v[38] == 928);
	11589	assert_or_panic(v[39] == 929);
	11590	assert_or_panic(v[40] == 930);
	11591	assert_or_panic(v[41] == 931);
	11592	assert_or_panic(v[42] == 932);
	11593	assert_or_panic(v[43] == 933);
	11594	assert_or_panic(v[44] == 934);
	11595	assert_or_panic(v[45] == 935);
	11596	assert_or_panic(v[46] == 936);
	11597	assert_or_panic(v[47] == 937);
	11598	assert_or_panic(v[48] == 938);
	11599	assert_or_panic(v[49] == 939);
	11600	assert_or_panic(v[50] == 940);
	11601	assert_or_panic(v[51] == 941);
	11602	assert_or_panic(v[52] == 942);
	11603	assert_or_panic(v[53] == 943);
	11604	assert_or_panic(v[54] == 944);
	11605	assert_or_panic(v[55] == 945);
	11606	assert_or_panic(v[56] == 946);
	11607	assert_or_panic(v[57] == 947);
	11608	assert_or_panic(v[58] == 948);
	11609	assert_or_panic(v[59] == 949);
	11610	assert_or_panic(v[60] == 950);
	11611	assert_or_panic(v[61] == 951);
	11612	assert_or_panic(v[62] == 952);
	11613	assert_or_panic(v[63] == 953);
	11614	assert_or_panic(v[64] == 954);
	11615	assert_or_panic(v[65] == 955);
	11616	assert_or_panic(v[66] == 956);
	11617	assert_or_panic(v[67] == 957);
	11618	assert_or_panic(v[68] == 958);
	11619	assert_or_panic(v[69] == 959);
	11620	assert_or_panic(v[70] == 960);
	11621	assert_or_panic(v[71] == 961);
	11622	assert_or_panic(v[72] == 962);
	11623	assert_or_panic(v[73] == 963);
	11624	assert_or_panic(v[74] == 964);
	11625	assert_or_panic(v[75] == 965);
	11626	assert_or_panic(v[76] == 966);
	11627	assert_or_panic(v[77] == 967);
	11628	assert_or_panic(v[78] == 968);
	11629	assert_or_panic(v[79] == 969);
	11630	assert_or_panic(v[80] == 970);
	11631	assert_or_panic(v[81] == 971);
	11632	assert_or_panic(v[82] == 972);
	11633	assert_or_panic(v[83] == 973);
	11634	assert_or_panic(v[84] == 974);
	11635	assert_or_panic(v[85] == 975);
	11636	assert_or_panic(v[86] == 976);
	11637	assert_or_panic(v[87] == 977);
	11638	assert_or_panic(v[88] == 978);
	11639	assert_or_panic(v[89] == 979);
	11640	assert_or_panic(v[90] == 980);
	11641	assert_or_panic(v[91] == 981);
	11642	assert_or_panic(v[92] == 982);
	11643	assert_or_panic(v[93] == 983);
	11644	assert_or_panic(v[94] == 984);
	11645	assert_or_panic(v[95] == 985);
	11646	zig_vector_96_u32((Vector_96_u32){
	11647	986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001,
	11648	1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017,
	11649	1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033,
	11650	1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049,
	11651	1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065,
	11652	1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081,
	11653	}, 96);
	11654	}
	11655
	11656	typedef uint32_t Vector_128_u32 __attribute__((vector_size(128 * sizeof(uint32_t))));
	11657
	11658	Vector_128_u32 zig_ret_vector_128_u32(void);
	11659	void zig_vector_128_u32(Vector_128_u32, size_t);
	11660
	11661	Vector_128_u32 c_ret_vector_128_u32(void) {
	11662	return (Vector_128_u32){
	11663	1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545,
	11664	1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561,
	11665	1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577,
	11666	1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593,
	11667	1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609,
	11668	1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625,
	11669	1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641,
	11670	1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657,
	11671	};
	11672	}
	11673	void c_vector_128_u32(Vector_128_u32 v, size_t i) {
	11674	assert_or_panic(v[0] == 1658);
	11675	assert_or_panic(v[1] == 1659);
	11676	assert_or_panic(v[2] == 1660);
	11677	assert_or_panic(v[3] == 1661);
	11678	assert_or_panic(v[4] == 1662);
	11679	assert_or_panic(v[5] == 1663);
	11680	assert_or_panic(v[6] == 1664);
	11681	assert_or_panic(v[7] == 1665);
	11682	assert_or_panic(v[8] == 1666);
	11683	assert_or_panic(v[9] == 1667);
	11684	assert_or_panic(v[10] == 1668);
	11685	assert_or_panic(v[11] == 1669);
	11686	assert_or_panic(v[12] == 1670);
	11687	assert_or_panic(v[13] == 1671);
	11688	assert_or_panic(v[14] == 1672);
	11689	assert_or_panic(v[15] == 1673);
	11690	assert_or_panic(v[16] == 1674);
	11691	assert_or_panic(v[17] == 1675);
	11692	assert_or_panic(v[18] == 1676);
	11693	assert_or_panic(v[19] == 1677);
	11694	assert_or_panic(v[20] == 1678);
	11695	assert_or_panic(v[21] == 1679);
	11696	assert_or_panic(v[22] == 1680);
	11697	assert_or_panic(v[23] == 1681);
	11698	assert_or_panic(v[24] == 1682);
	11699	assert_or_panic(v[25] == 1683);
	11700	assert_or_panic(v[26] == 1684);
	11701	assert_or_panic(v[27] == 1685);
	11702	assert_or_panic(v[28] == 1686);
	11703	assert_or_panic(v[29] == 1687);
	11704	assert_or_panic(v[30] == 1688);
	11705	assert_or_panic(v[31] == 1689);
	11706	assert_or_panic(v[32] == 1690);
	11707	assert_or_panic(v[33] == 1691);
	11708	assert_or_panic(v[34] == 1692);
	11709	assert_or_panic(v[35] == 1693);
	11710	assert_or_panic(v[36] == 1694);
	11711	assert_or_panic(v[37] == 1695);
	11712	assert_or_panic(v[38] == 1696);
	11713	assert_or_panic(v[39] == 1697);
	11714	assert_or_panic(v[40] == 1698);
	11715	assert_or_panic(v[41] == 1699);
	11716	assert_or_panic(v[42] == 1700);
	11717	assert_or_panic(v[43] == 1701);
	11718	assert_or_panic(v[44] == 1702);
	11719	assert_or_panic(v[45] == 1703);
	11720	assert_or_panic(v[46] == 1704);
	11721	assert_or_panic(v[47] == 1705);
	11722	assert_or_panic(v[48] == 1706);
	11723	assert_or_panic(v[49] == 1707);
	11724	assert_or_panic(v[50] == 1708);
	11725	assert_or_panic(v[51] == 1709);
	11726	assert_or_panic(v[52] == 1710);
	11727	assert_or_panic(v[53] == 1711);
	11728	assert_or_panic(v[54] == 1712);
	11729	assert_or_panic(v[55] == 1713);
	11730	assert_or_panic(v[56] == 1714);
	11731	assert_or_panic(v[57] == 1715);
	11732	assert_or_panic(v[58] == 1716);
	11733	assert_or_panic(v[59] == 1717);
	11734	assert_or_panic(v[60] == 1718);
	11735	assert_or_panic(v[61] == 1719);
	11736	assert_or_panic(v[62] == 1720);
	11737	assert_or_panic(v[63] == 1721);
	11738	assert_or_panic(v[64] == 1722);
	11739	assert_or_panic(v[65] == 1723);
	11740	assert_or_panic(v[66] == 1724);
	11741	assert_or_panic(v[67] == 1725);
	11742	assert_or_panic(v[68] == 1726);
	11743	assert_or_panic(v[69] == 1727);
	11744	assert_or_panic(v[70] == 1728);
	11745	assert_or_panic(v[71] == 1729);
	11746	assert_or_panic(v[72] == 1730);
	11747	assert_or_panic(v[73] == 1731);
	11748	assert_or_panic(v[74] == 1732);
	11749	assert_or_panic(v[75] == 1733);
	11750	assert_or_panic(v[76] == 1734);
	11751	assert_or_panic(v[77] == 1735);
	11752	assert_or_panic(v[78] == 1736);
	11753	assert_or_panic(v[79] == 1737);
	11754	assert_or_panic(v[80] == 1738);
	11755	assert_or_panic(v[81] == 1739);
	11756	assert_or_panic(v[82] == 1740);
	11757	assert_or_panic(v[83] == 1741);
	11758	assert_or_panic(v[84] == 1742);
	11759	assert_or_panic(v[85] == 1743);
	11760	assert_or_panic(v[86] == 1744);
	11761	assert_or_panic(v[87] == 1745);
	11762	assert_or_panic(v[88] == 1746);
	11763	assert_or_panic(v[89] == 1747);
	11764	assert_or_panic(v[90] == 1748);
	11765	assert_or_panic(v[91] == 1749);
	11766	assert_or_panic(v[92] == 1750);
	11767	assert_or_panic(v[93] == 1751);
	11768	assert_or_panic(v[94] == 1752);
	11769	assert_or_panic(v[95] == 1753);
	11770	assert_or_panic(v[96] == 1754);
	11771	assert_or_panic(v[97] == 1755);
	11772	assert_or_panic(v[98] == 1756);
	11773	assert_or_panic(v[99] == 1757);
	11774	assert_or_panic(v[100] == 1758);
	11775	assert_or_panic(v[101] == 1759);
	11776	assert_or_panic(v[102] == 1760);
	11777	assert_or_panic(v[103] == 1761);
	11778	assert_or_panic(v[104] == 1762);
	11779	assert_or_panic(v[105] == 1763);
	11780	assert_or_panic(v[106] == 1764);
	11781	assert_or_panic(v[107] == 1765);
	11782	assert_or_panic(v[108] == 1766);
	11783	assert_or_panic(v[109] == 1767);
	11784	assert_or_panic(v[110] == 1768);
	11785	assert_or_panic(v[111] == 1769);
	11786	assert_or_panic(v[112] == 1770);
	11787	assert_or_panic(v[113] == 1771);
	11788	assert_or_panic(v[114] == 1772);
	11789	assert_or_panic(v[115] == 1773);
	11790	assert_or_panic(v[116] == 1774);
	11791	assert_or_panic(v[117] == 1775);
	11792	assert_or_panic(v[118] == 1776);
	11793	assert_or_panic(v[119] == 1777);
	11794	assert_or_panic(v[120] == 1778);
	11795	assert_or_panic(v[121] == 1779);
	11796	assert_or_panic(v[122] == 1780);
	11797	assert_or_panic(v[123] == 1781);
	11798	assert_or_panic(v[124] == 1782);
	11799	assert_or_panic(v[125] == 1783);
	11800	assert_or_panic(v[126] == 1784);
	11801	assert_or_panic(v[127] == 1785);
	11802	assert_or_panic(i == 128);
	11803	}
	11804	void c_test_vector_128_u32(void) {
	11805	Vector_128_u32 v = zig_ret_vector_128_u32();
	11806	assert_or_panic(v[0] == 1274);
	11807	assert_or_panic(v[1] == 1275);
	11808	assert_or_panic(v[2] == 1276);
	11809	assert_or_panic(v[3] == 1277);
	11810	assert_or_panic(v[4] == 1278);
	11811	assert_or_panic(v[5] == 1279);
	11812	assert_or_panic(v[6] == 1280);
	11813	assert_or_panic(v[7] == 1281);
	11814	assert_or_panic(v[8] == 1282);
	11815	assert_or_panic(v[9] == 1283);
	11816	assert_or_panic(v[10] == 1284);
	11817	assert_or_panic(v[11] == 1285);
	11818	assert_or_panic(v[12] == 1286);
	11819	assert_or_panic(v[13] == 1287);
	11820	assert_or_panic(v[14] == 1288);
	11821	assert_or_panic(v[15] == 1289);
	11822	assert_or_panic(v[16] == 1290);
	11823	assert_or_panic(v[17] == 1291);
	11824	assert_or_panic(v[18] == 1292);
	11825	assert_or_panic(v[19] == 1293);
	11826	assert_or_panic(v[20] == 1294);
	11827	assert_or_panic(v[21] == 1295);
	11828	assert_or_panic(v[22] == 1296);
	11829	assert_or_panic(v[23] == 1297);
	11830	assert_or_panic(v[24] == 1298);
	11831	assert_or_panic(v[25] == 1299);
	11832	assert_or_panic(v[26] == 1300);
	11833	assert_or_panic(v[27] == 1301);
	11834	assert_or_panic(v[28] == 1302);
	11835	assert_or_panic(v[29] == 1303);
	11836	assert_or_panic(v[30] == 1304);
	11837	assert_or_panic(v[31] == 1305);
	11838	assert_or_panic(v[32] == 1306);
	11839	assert_or_panic(v[33] == 1307);
	11840	assert_or_panic(v[34] == 1308);
	11841	assert_or_panic(v[35] == 1309);
	11842	assert_or_panic(v[36] == 1310);
	11843	assert_or_panic(v[37] == 1311);
	11844	assert_or_panic(v[38] == 1312);
	11845	assert_or_panic(v[39] == 1313);
	11846	assert_or_panic(v[40] == 1314);
	11847	assert_or_panic(v[41] == 1315);
	11848	assert_or_panic(v[42] == 1316);
	11849	assert_or_panic(v[43] == 1317);
	11850	assert_or_panic(v[44] == 1318);
	11851	assert_or_panic(v[45] == 1319);
	11852	assert_or_panic(v[46] == 1320);
	11853	assert_or_panic(v[47] == 1321);
	11854	assert_or_panic(v[48] == 1322);
	11855	assert_or_panic(v[49] == 1323);
	11856	assert_or_panic(v[50] == 1324);
	11857	assert_or_panic(v[51] == 1325);
	11858	assert_or_panic(v[52] == 1326);
	11859	assert_or_panic(v[53] == 1327);
	11860	assert_or_panic(v[54] == 1328);
	11861	assert_or_panic(v[55] == 1329);
	11862	assert_or_panic(v[56] == 1330);
	11863	assert_or_panic(v[57] == 1331);
	11864	assert_or_panic(v[58] == 1332);
	11865	assert_or_panic(v[59] == 1333);
	11866	assert_or_panic(v[60] == 1334);
	11867	assert_or_panic(v[61] == 1335);
	11868	assert_or_panic(v[62] == 1336);
	11869	assert_or_panic(v[63] == 1337);
	11870	assert_or_panic(v[64] == 1338);
	11871	assert_or_panic(v[65] == 1339);
	11872	assert_or_panic(v[66] == 1340);
	11873	assert_or_panic(v[67] == 1341);
	11874	assert_or_panic(v[68] == 1342);
	11875	assert_or_panic(v[69] == 1343);
	11876	assert_or_panic(v[70] == 1344);
	11877	assert_or_panic(v[71] == 1345);
	11878	assert_or_panic(v[72] == 1346);
	11879	assert_or_panic(v[73] == 1347);
	11880	assert_or_panic(v[74] == 1348);
	11881	assert_or_panic(v[75] == 1349);
	11882	assert_or_panic(v[76] == 1350);
	11883	assert_or_panic(v[77] == 1351);
	11884	assert_or_panic(v[78] == 1352);
	11885	assert_or_panic(v[79] == 1353);
	11886	assert_or_panic(v[80] == 1354);
	11887	assert_or_panic(v[81] == 1355);
	11888	assert_or_panic(v[82] == 1356);
	11889	assert_or_panic(v[83] == 1357);
	11890	assert_or_panic(v[84] == 1358);
	11891	assert_or_panic(v[85] == 1359);
	11892	assert_or_panic(v[86] == 1360);
	11893	assert_or_panic(v[87] == 1361);
	11894	assert_or_panic(v[88] == 1362);
	11895	assert_or_panic(v[89] == 1363);
	11896	assert_or_panic(v[90] == 1364);
	11897	assert_or_panic(v[91] == 1365);
	11898	assert_or_panic(v[92] == 1366);
	11899	assert_or_panic(v[93] == 1367);
	11900	assert_or_panic(v[94] == 1368);
	11901	assert_or_panic(v[95] == 1369);
	11902	assert_or_panic(v[96] == 1370);
	11903	assert_or_panic(v[97] == 1371);
	11904	assert_or_panic(v[98] == 1372);
	11905	assert_or_panic(v[99] == 1373);
	11906	assert_or_panic(v[100] == 1374);
	11907	assert_or_panic(v[101] == 1375);
	11908	assert_or_panic(v[102] == 1376);
	11909	assert_or_panic(v[103] == 1377);
	11910	assert_or_panic(v[104] == 1378);
	11911	assert_or_panic(v[105] == 1379);
	11912	assert_or_panic(v[106] == 1380);
	11913	assert_or_panic(v[107] == 1381);
	11914	assert_or_panic(v[108] == 1382);
	11915	assert_or_panic(v[109] == 1383);
	11916	assert_or_panic(v[110] == 1384);
	11917	assert_or_panic(v[111] == 1385);
	11918	assert_or_panic(v[112] == 1386);
	11919	assert_or_panic(v[113] == 1387);
	11920	assert_or_panic(v[114] == 1388);
	11921	assert_or_panic(v[115] == 1389);
	11922	assert_or_panic(v[116] == 1390);
	11923	assert_or_panic(v[117] == 1391);
	11924	assert_or_panic(v[118] == 1392);
	11925	assert_or_panic(v[119] == 1393);
	11926	assert_or_panic(v[120] == 1394);
	11927	assert_or_panic(v[121] == 1395);
	11928	assert_or_panic(v[122] == 1396);
	11929	assert_or_panic(v[123] == 1397);
	11930	assert_or_panic(v[124] == 1398);
	11931	assert_or_panic(v[125] == 1399);
	11932	assert_or_panic(v[126] == 1400);
	11933	assert_or_panic(v[127] == 1401);
	11934	zig_vector_128_u32((Vector_128_u32){
	11935	1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417,
	11936	1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433,
	11937	1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449,
	11938	1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465,
	11939	1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481,
	11940	1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497,
	11941	1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513,
	11942	1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529,
	11943	}, 128);
	11944	}
	11945
	11946	typedef uint64_t Vector_1_u64 __attribute__((vector_size(1 * sizeof(uint64_t))));
	11947
	11948	Vector_1_u64 zig_ret_vector_1_u64(void);
	11949	void zig_vector_1_u64(Vector_1_u64, size_t);
	11950
	11951	Vector_1_u64 c_ret_vector_1_u64(void) {
	11952	return (Vector_1_u64){ 3 };
	11953	}
	11954	void c_vector_1_u64(Vector_1_u64 v, size_t i) {
	11955	assert_or_panic(v[0] == 4);
	11956	assert_or_panic(i == 1);
	11957	}
	11958	void c_test_vector_1_u64(void) {
	11959	Vector_1_u64 v = zig_ret_vector_1_u64();
	11960	assert_or_panic(v[0] == 1);
	11961	zig_vector_1_u64((Vector_1_u64){ 2 }, 1);
	11962	}
	11963
	11964	typedef uint64_t Vector_2_u64 __attribute__((vector_size(2 * sizeof(uint64_t))));
	11965
	11966	Vector_2_u64 zig_ret_vector_2_u64(void);
	11967	void zig_vector_2_u64(Vector_2_u64, size_t);
	11968
	11969	Vector_2_u64 c_ret_vector_2_u64(void) {
	11970	return (Vector_2_u64){ 9, 10 };
	11971	}
	11972	void c_vector_2_u64(Vector_2_u64 v, size_t i) {
	11973	assert_or_panic(v[0] == 11);
	11974	assert_or_panic(v[1] == 12);
	11975	assert_or_panic(i == 2);
	11976	}
	11977	void c_test_vector_2_u64(void) {
	11978	Vector_2_u64 v = zig_ret_vector_2_u64();
	11979	assert_or_panic(v[0] == 5);
	11980	assert_or_panic(v[1] == 6);
	11981	zig_vector_2_u64((Vector_2_u64){ 7, 8 }, 2);
	11982	}
	11983
	11984	typedef uint64_t Vector_3_u64 __attribute__((vector_size(3 * sizeof(uint64_t))));
	11985
	11986	Vector_3_u64 zig_ret_vector_3_u64(void);
	11987	void zig_vector_3_u64(Vector_3_u64, size_t);
	11988
	11989	Vector_3_u64 c_ret_vector_3_u64(void) {
	11990	return (Vector_3_u64){ 19, 20, 21 };
	11991	}
	11992	void c_vector_3_u64(Vector_3_u64 v, size_t i) {
	11993	assert_or_panic(v[0] == 22);
	11994	assert_or_panic(v[1] == 23);
	11995	assert_or_panic(v[2] == 24);
	11996	assert_or_panic(i == 3);
	11997	}
	11998	void c_test_vector_3_u64(void) {
	11999	Vector_3_u64 v = zig_ret_vector_3_u64();
	12000	assert_or_panic(v[0] == 13);
	12001	assert_or_panic(v[1] == 14);
	12002	assert_or_panic(v[2] == 15);
	12003	zig_vector_3_u64((Vector_3_u64){ 16, 17, 18 }, 3);
	12004	}
	12005
	12006	typedef uint64_t Vector_4_u64 __attribute__((vector_size(4 * sizeof(uint64_t))));
	12007
	12008	Vector_4_u64 zig_ret_vector_4_u64(void);
	12009	void zig_vector_4_u64(Vector_4_u64, size_t);
	12010
	12011	Vector_4_u64 c_ret_vector_4_u64(void) {
	12012	return (Vector_4_u64){ 33, 34, 35, 36 };
	12013	}
	12014	void c_vector_4_u64(Vector_4_u64 v, size_t i) {
	12015	assert_or_panic(v[0] == 37);
	12016	assert_or_panic(v[1] == 38);
	12017	assert_or_panic(v[2] == 39);
	12018	assert_or_panic(v[3] == 40);
	12019	assert_or_panic(i == 4);
	12020	}
	12021	void c_test_vector_4_u64(void) {
	12022	Vector_4_u64 v = zig_ret_vector_4_u64();
	12023	assert_or_panic(v[0] == 25);
	12024	assert_or_panic(v[1] == 26);
	12025	assert_or_panic(v[2] == 27);
	12026	assert_or_panic(v[3] == 28);
	12027	zig_vector_4_u64((Vector_4_u64){ 29, 30, 31, 32 }, 4);
	12028	}
	12029
	12030	typedef uint64_t Vector_6_u64 __attribute__((vector_size(6 * sizeof(uint64_t))));
	12031
	12032	Vector_6_u64 zig_ret_vector_6_u64(void);
	12033	void zig_vector_6_u64(Vector_6_u64, size_t);
	12034
	12035	Vector_6_u64 c_ret_vector_6_u64(void) {
	12036	return (Vector_6_u64){ 53, 54, 55, 56, 57, 58 };
	12037	}
	12038	void c_vector_6_u64(Vector_6_u64 v, size_t i) {
	12039	assert_or_panic(v[0] == 59);
	12040	assert_or_panic(v[1] == 60);
	12041	assert_or_panic(v[2] == 61);
	12042	assert_or_panic(v[3] == 62);
	12043	assert_or_panic(v[4] == 63);
	12044	assert_or_panic(v[5] == 64);
	12045	assert_or_panic(i == 6);
	12046	}
	12047	void c_test_vector_6_u64(void) {
	12048	Vector_6_u64 v = zig_ret_vector_6_u64();
	12049	assert_or_panic(v[0] == 41);
	12050	assert_or_panic(v[1] == 42);
	12051	assert_or_panic(v[2] == 43);
	12052	assert_or_panic(v[3] == 44);
	12053	assert_or_panic(v[4] == 45);
	12054	assert_or_panic(v[5] == 46);
	12055	zig_vector_6_u64((Vector_6_u64){ 47, 48, 49, 50, 51, 52 }, 6);
	12056	}
	12057
	12058	typedef uint64_t Vector_8_u64 __attribute__((vector_size(8 * sizeof(uint64_t))));
	12059
	12060	Vector_8_u64 zig_ret_vector_8_u64(void);
	12061	void zig_vector_8_u64(Vector_8_u64, size_t);
	12062
	12063	Vector_8_u64 c_ret_vector_8_u64(void) {
	12064	return (Vector_8_u64){ 81, 82, 83, 84, 85, 86, 87, 88 };
	12065	}
	12066	void c_vector_8_u64(Vector_8_u64 v, size_t i) {
	12067	assert_or_panic(v[0] == 89);
	12068	assert_or_panic(v[1] == 90);
	12069	assert_or_panic(v[2] == 91);
	12070	assert_or_panic(v[3] == 92);
	12071	assert_or_panic(v[4] == 93);
	12072	assert_or_panic(v[5] == 94);
	12073	assert_or_panic(v[6] == 95);
	12074	assert_or_panic(v[7] == 96);
	12075	assert_or_panic(i == 8);
	12076	}
	12077	void c_test_vector_8_u64(void) {
	12078	Vector_8_u64 v = zig_ret_vector_8_u64();
	12079	assert_or_panic(v[0] == 65);
	12080	assert_or_panic(v[1] == 66);
	12081	assert_or_panic(v[2] == 67);
	12082	assert_or_panic(v[3] == 68);
	12083	assert_or_panic(v[4] == 69);
	12084	assert_or_panic(v[5] == 70);
	12085	assert_or_panic(v[6] == 71);
	12086	assert_or_panic(v[7] == 72);
	12087	zig_vector_8_u64((Vector_8_u64){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8);
	12088	}
	12089
	12090	typedef uint64_t Vector_12_u64 __attribute__((vector_size(12 * sizeof(uint64_t))));
	12091
	12092	Vector_12_u64 zig_ret_vector_12_u64(void);
	12093	void zig_vector_12_u64(Vector_12_u64, size_t);
	12094
	12095	Vector_12_u64 c_ret_vector_12_u64(void) {
	12096	return (Vector_12_u64){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 };
	12097	}
	12098	void c_vector_12_u64(Vector_12_u64 v, size_t i) {
	12099	assert_or_panic(v[0] == 133);
	12100	assert_or_panic(v[1] == 134);
	12101	assert_or_panic(v[2] == 135);
	12102	assert_or_panic(v[3] == 136);
	12103	assert_or_panic(v[4] == 137);
	12104	assert_or_panic(v[5] == 138);
	12105	assert_or_panic(v[6] == 139);
	12106	assert_or_panic(v[7] == 140);
	12107	assert_or_panic(v[8] == 141);
	12108	assert_or_panic(v[9] == 142);
	12109	assert_or_panic(v[10] == 143);
	12110	assert_or_panic(v[11] == 144);
	12111	assert_or_panic(i == 12);
	12112	}
	12113	void c_test_vector_12_u64(void) {
	12114	Vector_12_u64 v = zig_ret_vector_12_u64();
	12115	assert_or_panic(v[0] == 97);
	12116	assert_or_panic(v[1] == 98);
	12117	assert_or_panic(v[2] == 99);
	12118	assert_or_panic(v[3] == 100);
	12119	assert_or_panic(v[4] == 101);
	12120	assert_or_panic(v[5] == 102);
	12121	assert_or_panic(v[6] == 103);
	12122	assert_or_panic(v[7] == 104);
	12123	assert_or_panic(v[8] == 105);
	12124	assert_or_panic(v[9] == 106);
	12125	assert_or_panic(v[10] == 107);
	12126	assert_or_panic(v[11] == 108);
	12127	zig_vector_12_u64((Vector_12_u64){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12);
	12128	}
	12129
	12130	typedef uint64_t Vector_16_u64 __attribute__((vector_size(16 * sizeof(uint64_t))));
	12131
	12132	Vector_16_u64 zig_ret_vector_16_u64(void);
	12133	void zig_vector_16_u64(Vector_16_u64, size_t);
	12134
	12135	Vector_16_u64 c_ret_vector_16_u64(void) {
	12136	return (Vector_16_u64){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 };
	12137	}
	12138	void c_vector_16_u64(Vector_16_u64 v, size_t i) {
	12139	assert_or_panic(v[0] == 193);
	12140	assert_or_panic(v[1] == 194);
	12141	assert_or_panic(v[2] == 195);
	12142	assert_or_panic(v[3] == 196);
	12143	assert_or_panic(v[4] == 197);
	12144	assert_or_panic(v[5] == 198);
	12145	assert_or_panic(v[6] == 199);
	12146	assert_or_panic(v[7] == 200);
	12147	assert_or_panic(v[8] == 201);
	12148	assert_or_panic(v[9] == 202);
	12149	assert_or_panic(v[10] == 203);
	12150	assert_or_panic(v[11] == 204);
	12151	assert_or_panic(v[12] == 205);
	12152	assert_or_panic(v[13] == 206);
	12153	assert_or_panic(v[14] == 207);
	12154	assert_or_panic(v[15] == 208);
	12155	assert_or_panic(i == 16);
	12156	}
	12157	void c_test_vector_16_u64(void) {
	12158	Vector_16_u64 v = zig_ret_vector_16_u64();
	12159	assert_or_panic(v[0] == 145);
	12160	assert_or_panic(v[1] == 146);
	12161	assert_or_panic(v[2] == 147);
	12162	assert_or_panic(v[3] == 148);
	12163	assert_or_panic(v[4] == 149);
	12164	assert_or_panic(v[5] == 150);
	12165	assert_or_panic(v[6] == 151);
	12166	assert_or_panic(v[7] == 152);
	12167	assert_or_panic(v[8] == 153);
	12168	assert_or_panic(v[9] == 154);
	12169	assert_or_panic(v[10] == 155);
	12170	assert_or_panic(v[11] == 156);
	12171	assert_or_panic(v[12] == 157);
	12172	assert_or_panic(v[13] == 158);
	12173	assert_or_panic(v[14] == 159);
	12174	assert_or_panic(v[15] == 160);
	12175	zig_vector_16_u64((Vector_16_u64){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16);
	12176	}
	12177
	12178	typedef uint64_t Vector_24_u64 __attribute__((vector_size(24 * sizeof(uint64_t))));
	12179
	12180	Vector_24_u64 zig_ret_vector_24_u64(void);
	12181	void zig_vector_24_u64(Vector_24_u64, size_t);
	12182
	12183	Vector_24_u64 c_ret_vector_24_u64(void) {
	12184	return (Vector_24_u64){
	12185	257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
	12186	273, 274, 275, 276, 277, 278, 279, 280,
	12187	};
	12188	}
	12189	void c_vector_24_u64(Vector_24_u64 v, size_t i) {
	12190	assert_or_panic(v[0] == 281);
	12191	assert_or_panic(v[1] == 282);
	12192	assert_or_panic(v[2] == 283);
	12193	assert_or_panic(v[3] == 284);
	12194	assert_or_panic(v[4] == 285);
	12195	assert_or_panic(v[5] == 286);
	12196	assert_or_panic(v[6] == 287);
	12197	assert_or_panic(v[7] == 288);
	12198	assert_or_panic(v[8] == 289);
	12199	assert_or_panic(v[9] == 290);
	12200	assert_or_panic(v[10] == 291);
	12201	assert_or_panic(v[11] == 292);
	12202	assert_or_panic(v[12] == 293);
	12203	assert_or_panic(v[13] == 294);
	12204	assert_or_panic(v[14] == 295);
	12205	assert_or_panic(v[15] == 296);
	12206	assert_or_panic(v[16] == 297);
	12207	assert_or_panic(v[17] == 298);
	12208	assert_or_panic(v[18] == 299);
	12209	assert_or_panic(v[19] == 300);
	12210	assert_or_panic(v[20] == 301);
	12211	assert_or_panic(v[21] == 302);
	12212	assert_or_panic(v[22] == 303);
	12213	assert_or_panic(v[23] == 304);
	12214	assert_or_panic(i == 24);
	12215	}
	12216	void c_test_vector_24_u64(void) {
	12217	Vector_24_u64 v = zig_ret_vector_24_u64();
	12218	assert_or_panic(v[0] == 209);
	12219	assert_or_panic(v[1] == 210);
	12220	assert_or_panic(v[2] == 211);
	12221	assert_or_panic(v[3] == 212);
	12222	assert_or_panic(v[4] == 213);
	12223	assert_or_panic(v[5] == 214);
	12224	assert_or_panic(v[6] == 215);
	12225	assert_or_panic(v[7] == 216);
	12226	assert_or_panic(v[8] == 217);
	12227	assert_or_panic(v[9] == 218);
	12228	assert_or_panic(v[10] == 219);
	12229	assert_or_panic(v[11] == 220);
	12230	assert_or_panic(v[12] == 221);
	12231	assert_or_panic(v[13] == 222);
	12232	assert_or_panic(v[14] == 223);
	12233	assert_or_panic(v[15] == 224);
	12234	assert_or_panic(v[16] == 225);
	12235	assert_or_panic(v[17] == 226);
	12236	assert_or_panic(v[18] == 227);
	12237	assert_or_panic(v[19] == 228);
	12238	assert_or_panic(v[20] == 229);
	12239	assert_or_panic(v[21] == 230);
	12240	assert_or_panic(v[22] == 231);
	12241	assert_or_panic(v[23] == 232);
	12242	zig_vector_24_u64((Vector_24_u64){
	12243	233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
	12244	249, 250, 251, 252, 253, 254, 255, 256,
	12245	}, 24);
	12246	}
	12247
	12248	typedef uint64_t Vector_32_u64 __attribute__((vector_size(32 * sizeof(uint64_t))));
	12249
	12250	Vector_32_u64 zig_ret_vector_32_u64(void);
	12251	void zig_vector_32_u64(Vector_32_u64, size_t);
	12252
	12253	Vector_32_u64 c_ret_vector_32_u64(void) {
	12254	return (Vector_32_u64){
	12255	369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
	12256	385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400,
	12257	};
	12258	}
	12259	void c_vector_32_u64(Vector_32_u64 v, size_t i) {
	12260	assert_or_panic(v[0] == 401);
	12261	assert_or_panic(v[1] == 402);
	12262	assert_or_panic(v[2] == 403);
	12263	assert_or_panic(v[3] == 404);
	12264	assert_or_panic(v[4] == 405);
	12265	assert_or_panic(v[5] == 406);
	12266	assert_or_panic(v[6] == 407);
	12267	assert_or_panic(v[7] == 408);
	12268	assert_or_panic(v[8] == 409);
	12269	assert_or_panic(v[9] == 410);
	12270	assert_or_panic(v[10] == 411);
	12271	assert_or_panic(v[11] == 412);
	12272	assert_or_panic(v[12] == 413);
	12273	assert_or_panic(v[13] == 414);
	12274	assert_or_panic(v[14] == 415);
	12275	assert_or_panic(v[15] == 416);
	12276	assert_or_panic(v[16] == 417);
	12277	assert_or_panic(v[17] == 418);
	12278	assert_or_panic(v[18] == 419);
	12279	assert_or_panic(v[19] == 420);
	12280	assert_or_panic(v[20] == 421);
	12281	assert_or_panic(v[21] == 422);
	12282	assert_or_panic(v[22] == 423);
	12283	assert_or_panic(v[23] == 424);
	12284	assert_or_panic(v[24] == 425);
	12285	assert_or_panic(v[25] == 426);
	12286	assert_or_panic(v[26] == 427);
	12287	assert_or_panic(v[27] == 428);
	12288	assert_or_panic(v[28] == 429);
	12289	assert_or_panic(v[29] == 430);
	12290	assert_or_panic(v[30] == 431);
	12291	assert_or_panic(v[31] == 432);
	12292	assert_or_panic(i == 32);
	12293	}
	12294	void c_test_vector_32_u64(void) {
	12295	Vector_32_u64 v = zig_ret_vector_32_u64();
	12296	assert_or_panic(v[0] == 305);
	12297	assert_or_panic(v[1] == 306);
	12298	assert_or_panic(v[2] == 307);
	12299	assert_or_panic(v[3] == 308);
	12300	assert_or_panic(v[4] == 309);
	12301	assert_or_panic(v[5] == 310);
	12302	assert_or_panic(v[6] == 311);
	12303	assert_or_panic(v[7] == 312);
	12304	assert_or_panic(v[8] == 313);
	12305	assert_or_panic(v[9] == 314);
	12306	assert_or_panic(v[10] == 315);
	12307	assert_or_panic(v[11] == 316);
	12308	assert_or_panic(v[12] == 317);
	12309	assert_or_panic(v[13] == 318);
	12310	assert_or_panic(v[14] == 319);
	12311	assert_or_panic(v[15] == 320);
	12312	assert_or_panic(v[16] == 321);
	12313	assert_or_panic(v[17] == 322);
	12314	assert_or_panic(v[18] == 323);
	12315	assert_or_panic(v[19] == 324);
	12316	assert_or_panic(v[20] == 325);
	12317	assert_or_panic(v[21] == 326);
	12318	assert_or_panic(v[22] == 327);
	12319	assert_or_panic(v[23] == 328);
	12320	assert_or_panic(v[24] == 329);
	12321	assert_or_panic(v[25] == 330);
	12322	assert_or_panic(v[26] == 331);
	12323	assert_or_panic(v[27] == 332);
	12324	assert_or_panic(v[28] == 333);
	12325	assert_or_panic(v[29] == 334);
	12326	assert_or_panic(v[30] == 335);
	12327	assert_or_panic(v[31] == 336);
	12328	zig_vector_32_u64((Vector_32_u64){
	12329	337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
	12330	353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
	12331	}, 32);
	12332	}
	12333
	12334	typedef uint64_t Vector_48_u64 __attribute__((vector_size(48 * sizeof(uint64_t))));
	12335
	12336	Vector_48_u64 zig_ret_vector_48_u64(void);
	12337	void zig_vector_48_u64(Vector_48_u64, size_t);
	12338
	12339	Vector_48_u64 c_ret_vector_48_u64(void) {
	12340	return (Vector_48_u64){
	12341	529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544,
	12342	545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560,
	12343	561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576,
	12344	};
	12345	}
	12346	void c_vector_48_u64(Vector_48_u64 v, size_t i) {
	12347	assert_or_panic(v[0] == 577);
	12348	assert_or_panic(v[1] == 578);
	12349	assert_or_panic(v[2] == 579);
	12350	assert_or_panic(v[3] == 580);
	12351	assert_or_panic(v[4] == 581);
	12352	assert_or_panic(v[5] == 582);
	12353	assert_or_panic(v[6] == 583);
	12354	assert_or_panic(v[7] == 584);
	12355	assert_or_panic(v[8] == 585);
	12356	assert_or_panic(v[9] == 586);
	12357	assert_or_panic(v[10] == 587);
	12358	assert_or_panic(v[11] == 588);
	12359	assert_or_panic(v[12] == 589);
	12360	assert_or_panic(v[13] == 590);
	12361	assert_or_panic(v[14] == 591);
	12362	assert_or_panic(v[15] == 592);
	12363	assert_or_panic(v[16] == 593);
	12364	assert_or_panic(v[17] == 594);
	12365	assert_or_panic(v[18] == 595);
	12366	assert_or_panic(v[19] == 596);
	12367	assert_or_panic(v[20] == 597);
	12368	assert_or_panic(v[21] == 598);
	12369	assert_or_panic(v[22] == 599);
	12370	assert_or_panic(v[23] == 600);
	12371	assert_or_panic(v[24] == 601);
	12372	assert_or_panic(v[25] == 602);
	12373	assert_or_panic(v[26] == 603);
	12374	assert_or_panic(v[27] == 604);
	12375	assert_or_panic(v[28] == 605);
	12376	assert_or_panic(v[29] == 606);
	12377	assert_or_panic(v[30] == 607);
	12378	assert_or_panic(v[31] == 608);
	12379	assert_or_panic(v[32] == 609);
	12380	assert_or_panic(v[33] == 610);
	12381	assert_or_panic(v[34] == 611);
	12382	assert_or_panic(v[35] == 612);
	12383	assert_or_panic(v[36] == 613);
	12384	assert_or_panic(v[37] == 614);
	12385	assert_or_panic(v[38] == 615);
	12386	assert_or_panic(v[39] == 616);
	12387	assert_or_panic(v[40] == 617);
	12388	assert_or_panic(v[41] == 618);
	12389	assert_or_panic(v[42] == 619);
	12390	assert_or_panic(v[43] == 620);
	12391	assert_or_panic(v[44] == 621);
	12392	assert_or_panic(v[45] == 622);
	12393	assert_or_panic(v[46] == 623);
	12394	assert_or_panic(v[47] == 624);
	12395	assert_or_panic(i == 48);
	12396	}
	12397	void c_test_vector_48_u64(void) {
	12398	Vector_48_u64 v = zig_ret_vector_48_u64();
	12399	assert_or_panic(v[0] == 433);
	12400	assert_or_panic(v[1] == 434);
	12401	assert_or_panic(v[2] == 435);
	12402	assert_or_panic(v[3] == 436);
	12403	assert_or_panic(v[4] == 437);
	12404	assert_or_panic(v[5] == 438);
	12405	assert_or_panic(v[6] == 439);
	12406	assert_or_panic(v[7] == 440);
	12407	assert_or_panic(v[8] == 441);
	12408	assert_or_panic(v[9] == 442);
	12409	assert_or_panic(v[10] == 443);
	12410	assert_or_panic(v[11] == 444);
	12411	assert_or_panic(v[12] == 445);
	12412	assert_or_panic(v[13] == 446);
	12413	assert_or_panic(v[14] == 447);
	12414	assert_or_panic(v[15] == 448);
	12415	assert_or_panic(v[16] == 449);
	12416	assert_or_panic(v[17] == 450);
	12417	assert_or_panic(v[18] == 451);
	12418	assert_or_panic(v[19] == 452);
	12419	assert_or_panic(v[20] == 453);
	12420	assert_or_panic(v[21] == 454);
	12421	assert_or_panic(v[22] == 455);
	12422	assert_or_panic(v[23] == 456);
	12423	assert_or_panic(v[24] == 457);
	12424	assert_or_panic(v[25] == 458);
	12425	assert_or_panic(v[26] == 459);
	12426	assert_or_panic(v[27] == 460);
	12427	assert_or_panic(v[28] == 461);
	12428	assert_or_panic(v[29] == 462);
	12429	assert_or_panic(v[30] == 463);
	12430	assert_or_panic(v[31] == 464);
	12431	assert_or_panic(v[32] == 465);
	12432	assert_or_panic(v[33] == 466);
	12433	assert_or_panic(v[34] == 467);
	12434	assert_or_panic(v[35] == 468);
	12435	assert_or_panic(v[36] == 469);
	12436	assert_or_panic(v[37] == 470);
	12437	assert_or_panic(v[38] == 471);
	12438	assert_or_panic(v[39] == 472);
	12439	assert_or_panic(v[40] == 473);
	12440	assert_or_panic(v[41] == 474);
	12441	assert_or_panic(v[42] == 475);
	12442	assert_or_panic(v[43] == 476);
	12443	assert_or_panic(v[44] == 477);
	12444	assert_or_panic(v[45] == 478);
	12445	assert_or_panic(v[46] == 479);
	12446	assert_or_panic(v[47] == 480);
	12447	zig_vector_48_u64((Vector_48_u64){
	12448	481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496,
	12449	497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
	12450	513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
	12451	}, 48);
	12452	}
	12453
	12454	typedef uint64_t Vector_64_u64 __attribute__((vector_size(64 * sizeof(uint64_t))));
	12455
	12456	Vector_64_u64 zig_ret_vector_64_u64(void);
	12457	void zig_vector_64_u64(Vector_64_u64, size_t);
	12458
	12459	Vector_64_u64 c_ret_vector_64_u64(void) {
	12460	return (Vector_64_u64){
	12461	753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768,
	12462	769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784,
	12463	785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800,
	12464	801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816,
	12465	};
	12466	}
	12467	void c_vector_64_u64(Vector_64_u64 v, size_t i) {
	12468	assert_or_panic(v[0] == 817);
	12469	assert_or_panic(v[1] == 818);
	12470	assert_or_panic(v[2] == 819);
	12471	assert_or_panic(v[3] == 820);
	12472	assert_or_panic(v[4] == 821);
	12473	assert_or_panic(v[5] == 822);
	12474	assert_or_panic(v[6] == 823);
	12475	assert_or_panic(v[7] == 824);
	12476	assert_or_panic(v[8] == 825);
	12477	assert_or_panic(v[9] == 826);
	12478	assert_or_panic(v[10] == 827);
	12479	assert_or_panic(v[11] == 828);
	12480	assert_or_panic(v[12] == 829);
	12481	assert_or_panic(v[13] == 830);
	12482	assert_or_panic(v[14] == 831);
	12483	assert_or_panic(v[15] == 832);
	12484	assert_or_panic(v[16] == 833);
	12485	assert_or_panic(v[17] == 834);
	12486	assert_or_panic(v[18] == 835);
	12487	assert_or_panic(v[19] == 836);
	12488	assert_or_panic(v[20] == 837);
	12489	assert_or_panic(v[21] == 838);
	12490	assert_or_panic(v[22] == 839);
	12491	assert_or_panic(v[23] == 840);
	12492	assert_or_panic(v[24] == 841);
	12493	assert_or_panic(v[25] == 842);
	12494	assert_or_panic(v[26] == 843);
	12495	assert_or_panic(v[27] == 844);
	12496	assert_or_panic(v[28] == 845);
	12497	assert_or_panic(v[29] == 846);
	12498	assert_or_panic(v[30] == 847);
	12499	assert_or_panic(v[31] == 848);
	12500	assert_or_panic(v[32] == 849);
	12501	assert_or_panic(v[33] == 850);
	12502	assert_or_panic(v[34] == 851);
	12503	assert_or_panic(v[35] == 852);
	12504	assert_or_panic(v[36] == 853);
	12505	assert_or_panic(v[37] == 854);
	12506	assert_or_panic(v[38] == 855);
	12507	assert_or_panic(v[39] == 856);
	12508	assert_or_panic(v[40] == 857);
	12509	assert_or_panic(v[41] == 858);
	12510	assert_or_panic(v[42] == 859);
	12511	assert_or_panic(v[43] == 860);
	12512	assert_or_panic(v[44] == 861);
	12513	assert_or_panic(v[45] == 862);
	12514	assert_or_panic(v[46] == 863);
	12515	assert_or_panic(v[47] == 864);
	12516	assert_or_panic(v[48] == 865);
	12517	assert_or_panic(v[49] == 866);
	12518	assert_or_panic(v[50] == 867);
	12519	assert_or_panic(v[51] == 868);
	12520	assert_or_panic(v[52] == 869);
	12521	assert_or_panic(v[53] == 870);
	12522	assert_or_panic(v[54] == 871);
	12523	assert_or_panic(v[55] == 872);
	12524	assert_or_panic(v[56] == 873);
	12525	assert_or_panic(v[57] == 874);
	12526	assert_or_panic(v[58] == 875);
	12527	assert_or_panic(v[59] == 876);
	12528	assert_or_panic(v[60] == 877);
	12529	assert_or_panic(v[61] == 878);
	12530	assert_or_panic(v[62] == 879);
	12531	assert_or_panic(v[63] == 880);
	12532	assert_or_panic(i == 64);
	12533	}
	12534	void c_test_vector_64_u64(void) {
	12535	Vector_64_u64 v = zig_ret_vector_64_u64();
	12536	assert_or_panic(v[0] == 625);
	12537	assert_or_panic(v[1] == 626);
	12538	assert_or_panic(v[2] == 627);
	12539	assert_or_panic(v[3] == 628);
	12540	assert_or_panic(v[4] == 629);
	12541	assert_or_panic(v[5] == 630);
	12542	assert_or_panic(v[6] == 631);
	12543	assert_or_panic(v[7] == 632);
	12544	assert_or_panic(v[8] == 633);
	12545	assert_or_panic(v[9] == 634);
	12546	assert_or_panic(v[10] == 635);
	12547	assert_or_panic(v[11] == 636);
	12548	assert_or_panic(v[12] == 637);
	12549	assert_or_panic(v[13] == 638);
	12550	assert_or_panic(v[14] == 639);
	12551	assert_or_panic(v[15] == 640);
	12552	assert_or_panic(v[16] == 641);
	12553	assert_or_panic(v[17] == 642);
	12554	assert_or_panic(v[18] == 643);
	12555	assert_or_panic(v[19] == 644);
	12556	assert_or_panic(v[20] == 645);
	12557	assert_or_panic(v[21] == 646);
	12558	assert_or_panic(v[22] == 647);
	12559	assert_or_panic(v[23] == 648);
	12560	assert_or_panic(v[24] == 649);
	12561	assert_or_panic(v[25] == 650);
	12562	assert_or_panic(v[26] == 651);
	12563	assert_or_panic(v[27] == 652);
	12564	assert_or_panic(v[28] == 653);
	12565	assert_or_panic(v[29] == 654);
	12566	assert_or_panic(v[30] == 655);
	12567	assert_or_panic(v[31] == 656);
	12568	assert_or_panic(v[32] == 657);
	12569	assert_or_panic(v[33] == 658);
	12570	assert_or_panic(v[34] == 659);
	12571	assert_or_panic(v[35] == 660);
	12572	assert_or_panic(v[36] == 661);
	12573	assert_or_panic(v[37] == 662);
	12574	assert_or_panic(v[38] == 663);
	12575	assert_or_panic(v[39] == 664);
	12576	assert_or_panic(v[40] == 665);
	12577	assert_or_panic(v[41] == 666);
	12578	assert_or_panic(v[42] == 667);
	12579	assert_or_panic(v[43] == 668);
	12580	assert_or_panic(v[44] == 669);
	12581	assert_or_panic(v[45] == 670);
	12582	assert_or_panic(v[46] == 671);
	12583	assert_or_panic(v[47] == 672);
	12584	assert_or_panic(v[48] == 673);
	12585	assert_or_panic(v[49] == 674);
	12586	assert_or_panic(v[50] == 675);
	12587	assert_or_panic(v[51] == 676);
	12588	assert_or_panic(v[52] == 677);
	12589	assert_or_panic(v[53] == 678);
	12590	assert_or_panic(v[54] == 679);
	12591	assert_or_panic(v[55] == 680);
	12592	assert_or_panic(v[56] == 681);
	12593	assert_or_panic(v[57] == 682);
	12594	assert_or_panic(v[58] == 683);
	12595	assert_or_panic(v[59] == 684);
	12596	assert_or_panic(v[60] == 685);
	12597	assert_or_panic(v[61] == 686);
	12598	assert_or_panic(v[62] == 687);
	12599	assert_or_panic(v[63] == 688);
	12600	zig_vector_64_u64((Vector_64_u64){
	12601	689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704,
	12602	705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720,
	12603	721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736,
	12604	737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752,
	12605	}, 64);
	12606	}
	12607
	12608	typedef float Vector_1_f32 __attribute__((vector_size(1 * sizeof(float))));
	12609
	12610	Vector_1_f32 zig_ret_vector_1_f32(void);
	12611	void zig_vector_1_f32(Vector_1_f32, size_t);
	12612
	12613	Vector_1_f32 c_ret_vector_1_f32(void) {
	12614	return (Vector_1_f32){ 3 };
	12615	}
	12616	void c_vector_1_f32(Vector_1_f32 v, size_t i) {
	12617	assert_or_panic(v[0] == 4);
	12618	assert_or_panic(i == 1);
	12619	}
	12620	void c_test_vector_1_f32(void) {
	12621	Vector_1_f32 v = zig_ret_vector_1_f32();
	12622	assert_or_panic(v[0] == 1);
	12623	zig_vector_1_f32((Vector_1_f32){ 2 }, 1);
	12624	}
	12625
	12626	typedef float Vector_2_f32 __attribute__((vector_size(2 * sizeof(float))));
	12627
	12628	Vector_2_f32 zig_ret_vector_2_f32(void);
	12629	void zig_vector_2_f32(Vector_2_f32, size_t);
	12630
	12631	Vector_2_f32 c_ret_vector_2_f32(void) {
	12632	return (Vector_2_f32){ 9, 10 };
	12633	}
	12634	void c_vector_2_f32(Vector_2_f32 v, size_t i) {
	12635	assert_or_panic(v[0] == 11);
	12636	assert_or_panic(v[1] == 12);
	12637	assert_or_panic(i == 2);
	12638	}
	12639	void c_test_vector_2_f32(void) {
	12640	Vector_2_f32 v = zig_ret_vector_2_f32();
	12641	assert_or_panic(v[0] == 5);
	12642	assert_or_panic(v[1] == 6);
	12643	zig_vector_2_f32((Vector_2_f32){ 7, 8 }, 2);
	12644	}
	12645
	12646	typedef float Vector_3_f32 __attribute__((vector_size(3 * sizeof(float))));
	12647
	12648	Vector_3_f32 zig_ret_vector_3_f32(void);
	12649	void zig_vector_3_f32(Vector_3_f32, size_t);
	12650
	12651	Vector_3_f32 c_ret_vector_3_f32(void) {
	12652	return (Vector_3_f32){ 19, 20, 21 };
	12653	}
	12654	void c_vector_3_f32(Vector_3_f32 v, size_t i) {
	12655	assert_or_panic(v[0] == 22);
	12656	assert_or_panic(v[1] == 23);
	12657	assert_or_panic(v[2] == 24);
	12658	assert_or_panic(i == 32);
	12659	}
	12660	void c_test_vector_3_f32(void) {
	12661	Vector_3_f32 v = zig_ret_vector_3_f32();
	12662	assert_or_panic(v[0] == 13);
	12663	assert_or_panic(v[1] == 14);
	12664	assert_or_panic(v[2] == 15);
	12665	zig_vector_3_f32((Vector_3_f32){ 16, 17, 18 }, 3);
	12666	}
	12667
	12668	typedef float Vector_4_f32 __attribute__((vector_size(4 * sizeof(float))));
	12669
	12670	Vector_4_f32 zig_ret_vector_4_f32(void);
	12671	void zig_vector_4_f32(Vector_4_f32, size_t);
	12672	void zig_vector_4_f32_vector_4_f32(Vector_4_f32, Vector_4_f32, size_t);
	12673
	12674	Vector_4_f32 c_ret_vector_4_f32(void) {
	12675	return (Vector_4_f32){ 41, 42, 43, 44 };
	12676	}
	12677	void c_vector_4_f32(Vector_4_f32 v, size_t i) {
	12678	assert_or_panic(v[0] == 45);
	12679	assert_or_panic(v[1] == 46);
	12680	assert_or_panic(v[2] == 47);
	12681	assert_or_panic(v[3] == 48);
	12682	assert_or_panic(i == 4);
	12683	}
	12684	void c_vector_4_f32_vector_4_f32(Vector_4_f32 v0, Vector_4_f32 v1, size_t i) {
	12685	assert_or_panic(v0[0] == 49);
	12686	assert_or_panic(v0[1] == 50);
	12687	assert_or_panic(v0[2] == 51);
	12688	assert_or_panic(v0[3] == 52);
	12689	assert_or_panic(v1[0] == 53);
	12690	assert_or_panic(v1[1] == 54);
	12691	assert_or_panic(v1[2] == 55);
	12692	assert_or_panic(v1[3] == 56);
	12693	assert_or_panic(i == 8);
	12694	}
	12695	void c_test_vector_4_f32(void) {
	12696	Vector_4_f32 v = zig_ret_vector_4_f32();
	12697	assert_or_panic(v[0] == 25);
	12698	assert_or_panic(v[1] == 26);
	12699	assert_or_panic(v[2] == 27);
	12700	assert_or_panic(v[3] == 28);
	12701	zig_vector_4_f32((Vector_4_f32){ 29, 30, 31, 32 }, 4);
	12702	zig_vector_4_f32_vector_4_f32((Vector_4_f32){ 33, 34, 35, 36 }, (Vector_4_f32){ 37, 38, 39, 40 }, 8);
	12703	}
	12704
	12705	typedef float Vector_6_f32 __attribute__((vector_size(6 * sizeof(float))));
	12706
	12707	Vector_6_f32 zig_ret_vector_6_f32(void);
	12708	void zig_vector_6_f32(Vector_6_f32, size_t);
	12709
	12710	Vector_6_f32 c_ret_vector_6_f32(void) {
	12711	return (Vector_6_f32){ 53, 54, 55, 56, 57, 58 };
	12712	}
	12713	void c_vector_6_f32(Vector_6_f32 v, size_t i) {
	12714	assert_or_panic(v[0] == 59);
	12715	assert_or_panic(v[1] == 60);
	12716	assert_or_panic(v[2] == 61);
	12717	assert_or_panic(v[3] == 62);
	12718	assert_or_panic(v[4] == 63);
	12719	assert_or_panic(v[5] == 64);
	12720	assert_or_panic(i == 6);
	12721	}
	12722	void c_test_vector_6_f32(void) {
	12723	Vector_6_f32 v = zig_ret_vector_6_f32();
	12724	assert_or_panic(v[0] == 41);
	12725	assert_or_panic(v[1] == 42);
	12726	assert_or_panic(v[2] == 43);
	12727	assert_or_panic(v[3] == 44);
	12728	assert_or_panic(v[4] == 45);
	12729	assert_or_panic(v[5] == 46);
	12730	zig_vector_6_f32((Vector_6_f32){ 47, 48, 49, 50, 51, 52 }, 6);
	12731	}
	12732
	12733	typedef float Vector_8_f32 __attribute__((vector_size(8 * sizeof(float))));
	12734
	12735	Vector_8_f32 zig_ret_vector_8_f32(void);
	12736	void zig_vector_8_f32(Vector_8_f32, size_t);
	12737
	12738	Vector_8_f32 c_ret_vector_8_f32(void) {
	12739	return (Vector_8_f32){ 81, 82, 83, 84, 85, 86, 87, 88 };
	12740	}
	12741	void c_vector_8_f32(Vector_8_f32 v, size_t i) {
	12742	assert_or_panic(v[0] == 89);
	12743	assert_or_panic(v[1] == 90);
	12744	assert_or_panic(v[2] == 91);
	12745	assert_or_panic(v[3] == 92);
	12746	assert_or_panic(v[4] == 93);
	12747	assert_or_panic(v[5] == 94);
	12748	assert_or_panic(v[6] == 95);
	12749	assert_or_panic(v[7] == 96);
	12750	assert_or_panic(i == 8);
	12751	}
	12752	void c_test_vector_8_f32(void) {
	12753	Vector_8_f32 v = zig_ret_vector_8_f32();
	12754	assert_or_panic(v[0] == 65);
	12755	assert_or_panic(v[1] == 66);
	12756	assert_or_panic(v[2] == 67);
	12757	assert_or_panic(v[3] == 68);
	12758	assert_or_panic(v[4] == 69);
	12759	assert_or_panic(v[5] == 70);
	12760	assert_or_panic(v[6] == 71);
	12761	assert_or_panic(v[7] == 72);
	12762	zig_vector_8_f32((Vector_8_f32){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8);
	12763	}
	12764
	12765	typedef float Vector_12_f32 __attribute__((vector_size(12 * sizeof(float))));
	12766
	12767	Vector_12_f32 zig_ret_vector_12_f32(void);
	12768	void zig_vector_12_f32(Vector_12_f32, size_t);
	12769
	12770	Vector_12_f32 c_ret_vector_12_f32(void) {
	12771	return (Vector_12_f32){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 };
	12772	}
	12773	void c_vector_12_f32(Vector_12_f32 v, size_t i) {
	12774	assert_or_panic(v[0] == 133);
	12775	assert_or_panic(v[1] == 134);
	12776	assert_or_panic(v[2] == 135);
	12777	assert_or_panic(v[3] == 136);
	12778	assert_or_panic(v[4] == 137);
	12779	assert_or_panic(v[5] == 138);
	12780	assert_or_panic(v[6] == 139);
	12781	assert_or_panic(v[7] == 140);
	12782	assert_or_panic(v[8] == 141);
	12783	assert_or_panic(v[9] == 142);
	12784	assert_or_panic(v[10] == 143);
	12785	assert_or_panic(v[11] == 144);
	12786	assert_or_panic(i == 12);
	12787	}
	12788	void c_test_vector_12_f32(void) {
	12789	Vector_12_f32 v = zig_ret_vector_12_f32();
	12790	assert_or_panic(v[0] == 97);
	12791	assert_or_panic(v[1] == 98);
	12792	assert_or_panic(v[2] == 99);
	12793	assert_or_panic(v[3] == 100);
	12794	assert_or_panic(v[4] == 101);
	12795	assert_or_panic(v[5] == 102);
	12796	assert_or_panic(v[6] == 103);
	12797	assert_or_panic(v[7] == 104);
	12798	assert_or_panic(v[8] == 105);
	12799	assert_or_panic(v[9] == 106);
	12800	assert_or_panic(v[10] == 107);
	12801	assert_or_panic(v[11] == 108);
	12802	zig_vector_12_f32((Vector_12_f32){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12);
	12803	}
	12804
	12805	typedef float Vector_16_f32 __attribute__((vector_size(16 * sizeof(float))));
	12806
	12807	Vector_16_f32 zig_ret_vector_16_f32(void);
	12808	void zig_vector_16_f32(Vector_16_f32, size_t);
	12809
	12810	Vector_16_f32 c_ret_vector_16_f32(void) {
	12811	return (Vector_16_f32){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 };
	12812	}
	12813	void c_vector_16_f32(Vector_16_f32 v, size_t i) {
	12814	assert_or_panic(v[0] == 193);
	12815	assert_or_panic(v[1] == 194);
	12816	assert_or_panic(v[2] == 195);
	12817	assert_or_panic(v[3] == 196);
	12818	assert_or_panic(v[4] == 197);
	12819	assert_or_panic(v[5] == 198);
	12820	assert_or_panic(v[6] == 199);
	12821	assert_or_panic(v[7] == 200);
	12822	assert_or_panic(v[8] == 201);
	12823	assert_or_panic(v[9] == 202);
	12824	assert_or_panic(v[10] == 203);
	12825	assert_or_panic(v[11] == 204);
	12826	assert_or_panic(v[12] == 205);
	12827	assert_or_panic(v[13] == 206);
	12828	assert_or_panic(v[14] == 207);
	12829	assert_or_panic(v[15] == 208);
	12830	assert_or_panic(i == 16);
	12831	}
	12832	void c_test_vector_16_f32(void) {
	12833	Vector_16_f32 v = zig_ret_vector_16_f32();
	12834	assert_or_panic(v[0] == 145);
	12835	assert_or_panic(v[1] == 146);
	12836	assert_or_panic(v[2] == 147);
	12837	assert_or_panic(v[3] == 148);
	12838	assert_or_panic(v[4] == 149);
	12839	assert_or_panic(v[5] == 150);
	12840	assert_or_panic(v[6] == 151);
	12841	assert_or_panic(v[7] == 152);
	12842	assert_or_panic(v[8] == 153);
	12843	assert_or_panic(v[9] == 154);
	12844	assert_or_panic(v[10] == 155);
	12845	assert_or_panic(v[11] == 156);
	12846	assert_or_panic(v[12] == 157);
	12847	assert_or_panic(v[13] == 158);
	12848	assert_or_panic(v[14] == 159);
	12849	assert_or_panic(v[15] == 160);
	12850	zig_vector_16_f32((Vector_16_f32){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16);
	12851	}
	12852
	12853	typedef float Vector_24_f32 __attribute__((vector_size(24 * sizeof(float))));
	12854
	12855	Vector_24_f32 zig_ret_vector_24_f32(void);
	12856	void zig_vector_24_f32(Vector_24_f32, size_t);
	12857
	12858	Vector_24_f32 c_ret_vector_24_f32(void) {
	12859	return (Vector_24_f32){
	12860	257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
	12861	273, 274, 275, 276, 277, 278, 279, 280,
	12862	};
	12863	}
	12864	void c_vector_24_f32(Vector_24_f32 v, size_t i) {
	12865	assert_or_panic(v[0] == 281);
	12866	assert_or_panic(v[1] == 282);
	12867	assert_or_panic(v[2] == 283);
	12868	assert_or_panic(v[3] == 284);
	12869	assert_or_panic(v[4] == 285);
	12870	assert_or_panic(v[5] == 286);
	12871	assert_or_panic(v[6] == 287);
	12872	assert_or_panic(v[7] == 288);
	12873	assert_or_panic(v[8] == 289);
	12874	assert_or_panic(v[9] == 290);
	12875	assert_or_panic(v[10] == 291);
	12876	assert_or_panic(v[11] == 292);
	12877	assert_or_panic(v[12] == 293);
	12878	assert_or_panic(v[13] == 294);
	12879	assert_or_panic(v[14] == 295);
	12880	assert_or_panic(v[15] == 296);
	12881	assert_or_panic(v[16] == 297);
	12882	assert_or_panic(v[17] == 298);
	12883	assert_or_panic(v[18] == 299);
	12884	assert_or_panic(v[19] == 300);
	12885	assert_or_panic(v[20] == 301);
	12886	assert_or_panic(v[21] == 302);
	12887	assert_or_panic(v[22] == 303);
	12888	assert_or_panic(v[23] == 304);
	12889	assert_or_panic(i == 24);
	12890	}
	12891	void c_test_vector_24_f32(void) {
	12892	Vector_24_f32 v = zig_ret_vector_24_f32();
	12893	assert_or_panic(v[0] == 209);
	12894	assert_or_panic(v[1] == 210);
	12895	assert_or_panic(v[2] == 211);
	12896	assert_or_panic(v[3] == 212);
	12897	assert_or_panic(v[4] == 213);
	12898	assert_or_panic(v[5] == 214);
	12899	assert_or_panic(v[6] == 215);
	12900	assert_or_panic(v[7] == 216);
	12901	assert_or_panic(v[8] == 217);
	12902	assert_or_panic(v[9] == 218);
	12903	assert_or_panic(v[10] == 219);
	12904	assert_or_panic(v[11] == 220);
	12905	assert_or_panic(v[12] == 221);
	12906	assert_or_panic(v[13] == 222);
	12907	assert_or_panic(v[14] == 223);
	12908	assert_or_panic(v[15] == 224);
	12909	assert_or_panic(v[16] == 225);
	12910	assert_or_panic(v[17] == 226);
	12911	assert_or_panic(v[18] == 227);
	12912	assert_or_panic(v[19] == 228);
	12913	assert_or_panic(v[20] == 229);
	12914	assert_or_panic(v[21] == 230);
	12915	assert_or_panic(v[22] == 231);
	12916	assert_or_panic(v[23] == 232);
	12917	zig_vector_24_f32((Vector_24_f32){
	12918	233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
	12919	249, 250, 251, 252, 253, 254, 255, 256,
	12920	}, 24);
	12921	}
	12922
	12923	typedef float Vector_32_f32 __attribute__((vector_size(32 * sizeof(float))));
	12924
	12925	Vector_32_f32 zig_ret_vector_32_f32(void);
	12926	void zig_vector_32_f32(Vector_32_f32, size_t);
	12927
	12928	Vector_32_f32 c_ret_vector_32_f32(void) {
	12929	return (Vector_32_f32){
	12930	369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
	12931	385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400,
	12932	};
	12933	}
	12934	void c_vector_32_f32(Vector_32_f32 v, size_t i) {
	12935	assert_or_panic(v[0] == 401);
	12936	assert_or_panic(v[1] == 402);
	12937	assert_or_panic(v[2] == 403);
	12938	assert_or_panic(v[3] == 404);
	12939	assert_or_panic(v[4] == 405);
	12940	assert_or_panic(v[5] == 406);
	12941	assert_or_panic(v[6] == 407);
	12942	assert_or_panic(v[7] == 408);
	12943	assert_or_panic(v[8] == 409);
	12944	assert_or_panic(v[9] == 410);
	12945	assert_or_panic(v[10] == 411);
	12946	assert_or_panic(v[11] == 412);
	12947	assert_or_panic(v[12] == 413);
	12948	assert_or_panic(v[13] == 414);
	12949	assert_or_panic(v[14] == 415);
	12950	assert_or_panic(v[15] == 416);
	12951	assert_or_panic(v[16] == 417);
	12952	assert_or_panic(v[17] == 418);
	12953	assert_or_panic(v[18] == 419);
	12954	assert_or_panic(v[19] == 420);
	12955	assert_or_panic(v[20] == 421);
	12956	assert_or_panic(v[21] == 422);
	12957	assert_or_panic(v[22] == 423);
	12958	assert_or_panic(v[23] == 424);
	12959	assert_or_panic(v[24] == 425);
	12960	assert_or_panic(v[25] == 426);
	12961	assert_or_panic(v[26] == 427);
	12962	assert_or_panic(v[27] == 428);
	12963	assert_or_panic(v[28] == 429);
	12964	assert_or_panic(v[29] == 430);
	12965	assert_or_panic(v[30] == 431);
	12966	assert_or_panic(v[31] == 432);
	12967	assert_or_panic(i == 32);
	12968	}
	12969	void c_test_vector_32_f32(void) {
	12970	Vector_32_f32 v = zig_ret_vector_32_f32();
	12971	assert_or_panic(v[0] == 305);
	12972	assert_or_panic(v[1] == 306);
	12973	assert_or_panic(v[2] == 307);
	12974	assert_or_panic(v[3] == 308);
	12975	assert_or_panic(v[4] == 309);
	12976	assert_or_panic(v[5] == 310);
	12977	assert_or_panic(v[6] == 311);
	12978	assert_or_panic(v[7] == 312);
	12979	assert_or_panic(v[8] == 313);
	12980	assert_or_panic(v[9] == 314);
	12981	assert_or_panic(v[10] == 315);
	12982	assert_or_panic(v[11] == 316);
	12983	assert_or_panic(v[12] == 317);
	12984	assert_or_panic(v[13] == 318);
	12985	assert_or_panic(v[14] == 319);
	12986	assert_or_panic(v[15] == 320);
	12987	assert_or_panic(v[16] == 321);
	12988	assert_or_panic(v[17] == 322);
	12989	assert_or_panic(v[18] == 323);
	12990	assert_or_panic(v[19] == 324);
	12991	assert_or_panic(v[20] == 325);
	12992	assert_or_panic(v[21] == 326);
	12993	assert_or_panic(v[22] == 327);
	12994	assert_or_panic(v[23] == 328);
	12995	assert_or_panic(v[24] == 329);
	12996	assert_or_panic(v[25] == 330);
	12997	assert_or_panic(v[26] == 331);
	12998	assert_or_panic(v[27] == 332);
	12999	assert_or_panic(v[28] == 333);
	13000	assert_or_panic(v[29] == 334);
	13001	assert_or_panic(v[30] == 335);
	13002	assert_or_panic(v[31] == 336);
	13003	zig_vector_32_f32((Vector_32_f32){
	13004	337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
	13005	353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
	13006	}, 32);
	13007	}
	13008
	13009	typedef float Vector_48_f32 __attribute__((vector_size(48 * sizeof(float))));
	13010
	13011	Vector_48_f32 zig_ret_vector_48_f32(void);
	13012	void zig_vector_48_f32(Vector_48_f32, size_t);
	13013
	13014	Vector_48_f32 c_ret_vector_48_f32(void) {
	13015	return (Vector_48_f32){
	13016	529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544,
	13017	545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560,
	13018	561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576,
	13019	};
	13020	}
	13021	void c_vector_48_f32(Vector_48_f32 v, size_t i) {
	13022	assert_or_panic(v[0] == 577);
	13023	assert_or_panic(v[1] == 578);
	13024	assert_or_panic(v[2] == 579);
	13025	assert_or_panic(v[3] == 580);
	13026	assert_or_panic(v[4] == 581);
	13027	assert_or_panic(v[5] == 582);
	13028	assert_or_panic(v[6] == 583);
	13029	assert_or_panic(v[7] == 584);
	13030	assert_or_panic(v[8] == 585);
	13031	assert_or_panic(v[9] == 586);
	13032	assert_or_panic(v[10] == 587);
	13033	assert_or_panic(v[11] == 588);
	13034	assert_or_panic(v[12] == 589);
	13035	assert_or_panic(v[13] == 590);
	13036	assert_or_panic(v[14] == 591);
	13037	assert_or_panic(v[15] == 592);
	13038	assert_or_panic(v[16] == 593);
	13039	assert_or_panic(v[17] == 594);
	13040	assert_or_panic(v[18] == 595);
	13041	assert_or_panic(v[19] == 596);
	13042	assert_or_panic(v[20] == 597);
	13043	assert_or_panic(v[21] == 598);
	13044	assert_or_panic(v[22] == 599);
	13045	assert_or_panic(v[23] == 600);
	13046	assert_or_panic(v[24] == 601);
	13047	assert_or_panic(v[25] == 602);
	13048	assert_or_panic(v[26] == 603);
	13049	assert_or_panic(v[27] == 604);
	13050	assert_or_panic(v[28] == 605);
	13051	assert_or_panic(v[29] == 606);
	13052	assert_or_panic(v[30] == 607);
	13053	assert_or_panic(v[31] == 608);
	13054	assert_or_panic(v[32] == 609);
	13055	assert_or_panic(v[33] == 610);
	13056	assert_or_panic(v[34] == 611);
	13057	assert_or_panic(v[35] == 612);
	13058	assert_or_panic(v[36] == 613);
	13059	assert_or_panic(v[37] == 614);
	13060	assert_or_panic(v[38] == 615);
	13061	assert_or_panic(v[39] == 616);
	13062	assert_or_panic(v[40] == 617);
	13063	assert_or_panic(v[41] == 618);
	13064	assert_or_panic(v[42] == 619);
	13065	assert_or_panic(v[43] == 620);
	13066	assert_or_panic(v[44] == 621);
	13067	assert_or_panic(v[45] == 622);
	13068	assert_or_panic(v[46] == 623);
	13069	assert_or_panic(v[47] == 624);
	13070	assert_or_panic(i == 48);
	13071	}
	13072	void c_test_vector_48_f32(void) {
	13073	Vector_48_f32 v = zig_ret_vector_48_f32();
	13074	assert_or_panic(v[0] == 433);
	13075	assert_or_panic(v[1] == 434);
	13076	assert_or_panic(v[2] == 435);
	13077	assert_or_panic(v[3] == 436);
	13078	assert_or_panic(v[4] == 437);
	13079	assert_or_panic(v[5] == 438);
	13080	assert_or_panic(v[6] == 439);
	13081	assert_or_panic(v[7] == 440);
	13082	assert_or_panic(v[8] == 441);
	13083	assert_or_panic(v[9] == 442);
	13084	assert_or_panic(v[10] == 443);
	13085	assert_or_panic(v[11] == 444);
	13086	assert_or_panic(v[12] == 445);
	13087	assert_or_panic(v[13] == 446);
	13088	assert_or_panic(v[14] == 447);
	13089	assert_or_panic(v[15] == 448);
	13090	assert_or_panic(v[16] == 449);
	13091	assert_or_panic(v[17] == 450);
	13092	assert_or_panic(v[18] == 451);
	13093	assert_or_panic(v[19] == 452);
	13094	assert_or_panic(v[20] == 453);
	13095	assert_or_panic(v[21] == 454);
	13096	assert_or_panic(v[22] == 455);
	13097	assert_or_panic(v[23] == 456);
	13098	assert_or_panic(v[24] == 457);
	13099	assert_or_panic(v[25] == 458);
	13100	assert_or_panic(v[26] == 459);
	13101	assert_or_panic(v[27] == 460);
	13102	assert_or_panic(v[28] == 461);
	13103	assert_or_panic(v[29] == 462);
	13104	assert_or_panic(v[30] == 463);
	13105	assert_or_panic(v[31] == 464);
	13106	assert_or_panic(v[32] == 465);
	13107	assert_or_panic(v[33] == 466);
	13108	assert_or_panic(v[34] == 467);
	13109	assert_or_panic(v[35] == 468);
	13110	assert_or_panic(v[36] == 469);
	13111	assert_or_panic(v[37] == 470);
	13112	assert_or_panic(v[38] == 471);
	13113	assert_or_panic(v[39] == 472);
	13114	assert_or_panic(v[40] == 473);
	13115	assert_or_panic(v[41] == 474);
	13116	assert_or_panic(v[42] == 475);
	13117	assert_or_panic(v[43] == 476);
	13118	assert_or_panic(v[44] == 477);
	13119	assert_or_panic(v[45] == 478);
	13120	assert_or_panic(v[46] == 479);
	13121	assert_or_panic(v[47] == 480);
	13122	zig_vector_48_f32((Vector_48_f32){
	13123	481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496,
	13124	497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
	13125	513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
	13126	}, 48);
	13127	}
	13128
	13129	typedef float Vector_64_f32 __attribute__((vector_size(64 * sizeof(float))));
	13130
	13131	Vector_64_f32 zig_ret_vector_64_f32(void);
	13132	void zig_vector_64_f32(Vector_64_f32, size_t);
	13133
	13134	Vector_64_f32 c_ret_vector_64_f32(void) {
	13135	return (Vector_64_f32){
	13136	753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768,
	13137	769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784,
	13138	785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800,
	13139	801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816,
	13140	};
	13141	}
	13142	void c_vector_64_f32(Vector_64_f32 v, size_t i) {
	13143	assert_or_panic(v[0] == 817);
	13144	assert_or_panic(v[1] == 818);
	13145	assert_or_panic(v[2] == 819);
	13146	assert_or_panic(v[3] == 820);
	13147	assert_or_panic(v[4] == 821);
	13148	assert_or_panic(v[5] == 822);
	13149	assert_or_panic(v[6] == 823);
	13150	assert_or_panic(v[7] == 824);
	13151	assert_or_panic(v[8] == 825);
	13152	assert_or_panic(v[9] == 826);
	13153	assert_or_panic(v[10] == 827);
	13154	assert_or_panic(v[11] == 828);
	13155	assert_or_panic(v[12] == 829);
	13156	assert_or_panic(v[13] == 830);
	13157	assert_or_panic(v[14] == 831);
	13158	assert_or_panic(v[15] == 832);
	13159	assert_or_panic(v[16] == 833);
	13160	assert_or_panic(v[17] == 834);
	13161	assert_or_panic(v[18] == 835);
	13162	assert_or_panic(v[19] == 836);
	13163	assert_or_panic(v[20] == 837);
	13164	assert_or_panic(v[21] == 838);
	13165	assert_or_panic(v[22] == 839);
	13166	assert_or_panic(v[23] == 840);
	13167	assert_or_panic(v[24] == 841);
	13168	assert_or_panic(v[25] == 842);
	13169	assert_or_panic(v[26] == 843);
	13170	assert_or_panic(v[27] == 844);
	13171	assert_or_panic(v[28] == 845);
	13172	assert_or_panic(v[29] == 846);
	13173	assert_or_panic(v[30] == 847);
	13174	assert_or_panic(v[31] == 848);
	13175	assert_or_panic(v[32] == 849);
	13176	assert_or_panic(v[33] == 850);
	13177	assert_or_panic(v[34] == 851);
	13178	assert_or_panic(v[35] == 852);
	13179	assert_or_panic(v[36] == 853);
	13180	assert_or_panic(v[37] == 854);
	13181	assert_or_panic(v[38] == 855);
	13182	assert_or_panic(v[39] == 856);
	13183	assert_or_panic(v[40] == 857);
	13184	assert_or_panic(v[41] == 858);
	13185	assert_or_panic(v[42] == 859);
	13186	assert_or_panic(v[43] == 860);
	13187	assert_or_panic(v[44] == 861);
	13188	assert_or_panic(v[45] == 862);
	13189	assert_or_panic(v[46] == 863);
	13190	assert_or_panic(v[47] == 864);
	13191	assert_or_panic(v[48] == 865);
	13192	assert_or_panic(v[49] == 866);
	13193	assert_or_panic(v[50] == 867);
	13194	assert_or_panic(v[51] == 868);
	13195	assert_or_panic(v[52] == 869);
	13196	assert_or_panic(v[53] == 870);
	13197	assert_or_panic(v[54] == 871);
	13198	assert_or_panic(v[55] == 872);
	13199	assert_or_panic(v[56] == 873);
	13200	assert_or_panic(v[57] == 874);
	13201	assert_or_panic(v[58] == 875);
	13202	assert_or_panic(v[59] == 876);
	13203	assert_or_panic(v[60] == 877);
	13204	assert_or_panic(v[61] == 878);
	13205	assert_or_panic(v[62] == 879);
	13206	assert_or_panic(v[63] == 880);
	13207	assert_or_panic(i == 64);
	13208	}
	13209	void c_test_vector_64_f32(void) {
	13210	Vector_64_f32 v = zig_ret_vector_64_f32();
	13211	assert_or_panic(v[0] == 625);
	13212	assert_or_panic(v[1] == 626);
	13213	assert_or_panic(v[2] == 627);
	13214	assert_or_panic(v[3] == 628);
	13215	assert_or_panic(v[4] == 629);
	13216	assert_or_panic(v[5] == 630);
	13217	assert_or_panic(v[6] == 631);
	13218	assert_or_panic(v[7] == 632);
	13219	assert_or_panic(v[8] == 633);
	13220	assert_or_panic(v[9] == 634);
	13221	assert_or_panic(v[10] == 635);
	13222	assert_or_panic(v[11] == 636);
	13223	assert_or_panic(v[12] == 637);
	13224	assert_or_panic(v[13] == 638);
	13225	assert_or_panic(v[14] == 639);
	13226	assert_or_panic(v[15] == 640);
	13227	assert_or_panic(v[16] == 641);
	13228	assert_or_panic(v[17] == 642);
	13229	assert_or_panic(v[18] == 643);
	13230	assert_or_panic(v[19] == 644);
	13231	assert_or_panic(v[20] == 645);
	13232	assert_or_panic(v[21] == 646);
	13233	assert_or_panic(v[22] == 647);
	13234	assert_or_panic(v[23] == 648);
	13235	assert_or_panic(v[24] == 649);
	13236	assert_or_panic(v[25] == 650);
	13237	assert_or_panic(v[26] == 651);
	13238	assert_or_panic(v[27] == 652);
	13239	assert_or_panic(v[28] == 653);
	13240	assert_or_panic(v[29] == 654);
	13241	assert_or_panic(v[30] == 655);
	13242	assert_or_panic(v[31] == 656);
	13243	assert_or_panic(v[32] == 657);
	13244	assert_or_panic(v[33] == 658);
	13245	assert_or_panic(v[34] == 659);
	13246	assert_or_panic(v[35] == 660);
	13247	assert_or_panic(v[36] == 661);
	13248	assert_or_panic(v[37] == 662);
	13249	assert_or_panic(v[38] == 663);
	13250	assert_or_panic(v[39] == 664);
	13251	assert_or_panic(v[40] == 665);
	13252	assert_or_panic(v[41] == 666);
	13253	assert_or_panic(v[42] == 667);
	13254	assert_or_panic(v[43] == 668);
	13255	assert_or_panic(v[44] == 669);
	13256	assert_or_panic(v[45] == 670);
	13257	assert_or_panic(v[46] == 671);
	13258	assert_or_panic(v[47] == 672);
	13259	assert_or_panic(v[48] == 673);
	13260	assert_or_panic(v[49] == 674);
	13261	assert_or_panic(v[50] == 675);
	13262	assert_or_panic(v[51] == 676);
	13263	assert_or_panic(v[52] == 677);
	13264	assert_or_panic(v[53] == 678);
	13265	assert_or_panic(v[54] == 679);
	13266	assert_or_panic(v[55] == 680);
	13267	assert_or_panic(v[56] == 681);
	13268	assert_or_panic(v[57] == 682);
	13269	assert_or_panic(v[58] == 683);
	13270	assert_or_panic(v[59] == 684);
	13271	assert_or_panic(v[60] == 685);
	13272	assert_or_panic(v[61] == 686);
	13273	assert_or_panic(v[62] == 687);
	13274	assert_or_panic(v[63] == 688);
	13275	zig_vector_64_f32((Vector_64_f32){
	13276	689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704,
	13277	705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720,
	13278	721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736,
	13279	737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752,
	13280	}, 64);
	13281	}
	13282
	13283	typedef float Vector_96_f32 __attribute__((vector_size(96 * sizeof(float))));
	13284
	13285	Vector_96_f32 zig_ret_vector_96_f32(void);
	13286	void zig_vector_96_f32(Vector_96_f32, size_t);
	13287
	13288	Vector_96_f32 c_ret_vector_96_f32(void) {
	13289	return (Vector_96_f32){
	13290	1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097,
	13291	1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113,
	13292	1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129,
	13293	1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145,
	13294	1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161,
	13295	1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177,
	13296	};
	13297	}
	13298	void c_vector_96_f32(Vector_96_f32 v, size_t i) {
	13299	assert_or_panic(v[0] == 1178);
	13300	assert_or_panic(v[1] == 1179);
	13301	assert_or_panic(v[2] == 1180);
	13302	assert_or_panic(v[3] == 1181);
	13303	assert_or_panic(v[4] == 1182);
	13304	assert_or_panic(v[5] == 1183);
	13305	assert_or_panic(v[6] == 1184);
	13306	assert_or_panic(v[7] == 1185);
	13307	assert_or_panic(v[8] == 1186);
	13308	assert_or_panic(v[9] == 1187);
	13309	assert_or_panic(v[10] == 1188);
	13310	assert_or_panic(v[11] == 1189);
	13311	assert_or_panic(v[12] == 1190);
	13312	assert_or_panic(v[13] == 1191);
	13313	assert_or_panic(v[14] == 1192);
	13314	assert_or_panic(v[15] == 1193);
	13315	assert_or_panic(v[16] == 1194);
	13316	assert_or_panic(v[17] == 1195);
	13317	assert_or_panic(v[18] == 1196);
	13318	assert_or_panic(v[19] == 1197);
	13319	assert_or_panic(v[20] == 1198);
	13320	assert_or_panic(v[21] == 1199);
	13321	assert_or_panic(v[22] == 1200);
	13322	assert_or_panic(v[23] == 1201);
	13323	assert_or_panic(v[24] == 1202);
	13324	assert_or_panic(v[25] == 1203);
	13325	assert_or_panic(v[26] == 1204);
	13326	assert_or_panic(v[27] == 1205);
	13327	assert_or_panic(v[28] == 1206);
	13328	assert_or_panic(v[29] == 1207);
	13329	assert_or_panic(v[30] == 1208);
	13330	assert_or_panic(v[31] == 1209);
	13331	assert_or_panic(v[32] == 1210);
	13332	assert_or_panic(v[33] == 1211);
	13333	assert_or_panic(v[34] == 1212);
	13334	assert_or_panic(v[35] == 1213);
	13335	assert_or_panic(v[36] == 1214);
	13336	assert_or_panic(v[37] == 1215);
	13337	assert_or_panic(v[38] == 1216);
	13338	assert_or_panic(v[39] == 1217);
	13339	assert_or_panic(v[40] == 1218);
	13340	assert_or_panic(v[41] == 1219);
	13341	assert_or_panic(v[42] == 1220);
	13342	assert_or_panic(v[43] == 1221);
	13343	assert_or_panic(v[44] == 1222);
	13344	assert_or_panic(v[45] == 1223);
	13345	assert_or_panic(v[46] == 1224);
	13346	assert_or_panic(v[47] == 1225);
	13347	assert_or_panic(v[48] == 1226);
	13348	assert_or_panic(v[49] == 1227);
	13349	assert_or_panic(v[50] == 1228);
	13350	assert_or_panic(v[51] == 1229);
	13351	assert_or_panic(v[52] == 1230);
	13352	assert_or_panic(v[53] == 1231);
	13353	assert_or_panic(v[54] == 1232);
	13354	assert_or_panic(v[55] == 1233);
	13355	assert_or_panic(v[56] == 1234);
	13356	assert_or_panic(v[57] == 1235);
	13357	assert_or_panic(v[58] == 1236);
	13358	assert_or_panic(v[59] == 1237);
	13359	assert_or_panic(v[60] == 1238);
	13360	assert_or_panic(v[61] == 1239);
	13361	assert_or_panic(v[62] == 1240);
	13362	assert_or_panic(v[63] == 1241);
	13363	assert_or_panic(v[64] == 1242);
	13364	assert_or_panic(v[65] == 1243);
	13365	assert_or_panic(v[66] == 1244);
	13366	assert_or_panic(v[67] == 1245);
	13367	assert_or_panic(v[68] == 1246);
	13368	assert_or_panic(v[69] == 1247);
	13369	assert_or_panic(v[70] == 1248);
	13370	assert_or_panic(v[71] == 1249);
	13371	assert_or_panic(v[72] == 1250);
	13372	assert_or_panic(v[73] == 1251);
	13373	assert_or_panic(v[74] == 1252);
	13374	assert_or_panic(v[75] == 1253);
	13375	assert_or_panic(v[76] == 1254);
	13376	assert_or_panic(v[77] == 1255);
	13377	assert_or_panic(v[80] == 1258);
	13378	assert_or_panic(v[81] == 1259);
	13379	assert_or_panic(v[82] == 1260);
	13380	assert_or_panic(v[83] == 1261);
	13381	assert_or_panic(v[84] == 1262);
	13382	assert_or_panic(v[85] == 1263);
	13383	assert_or_panic(v[86] == 1264);
	13384	assert_or_panic(v[87] == 1265);
	13385	assert_or_panic(v[88] == 1266);
	13386	assert_or_panic(v[89] == 1267);
	13387	assert_or_panic(v[90] == 1268);
	13388	assert_or_panic(v[91] == 1269);
	13389	assert_or_panic(v[92] == 1270);
	13390	assert_or_panic(v[93] == 1271);
	13391	assert_or_panic(v[94] == 1272);
	13392	assert_or_panic(v[95] == 1273);
	13393	assert_or_panic(i == 96);
	13394	}
	13395	void c_test_vector_96_f32(void) {
	13396	Vector_96_f32 v = zig_ret_vector_96_f32();
	13397	assert_or_panic(v[0] == 890);
	13398	assert_or_panic(v[1] == 891);
	13399	assert_or_panic(v[2] == 892);
	13400	assert_or_panic(v[3] == 893);
	13401	assert_or_panic(v[4] == 894);
	13402	assert_or_panic(v[5] == 895);
	13403	assert_or_panic(v[6] == 896);
	13404	assert_or_panic(v[7] == 897);
	13405	assert_or_panic(v[8] == 898);
	13406	assert_or_panic(v[9] == 899);
	13407	assert_or_panic(v[10] == 900);
	13408	assert_or_panic(v[11] == 901);
	13409	assert_or_panic(v[12] == 902);
	13410	assert_or_panic(v[13] == 903);
	13411	assert_or_panic(v[14] == 904);
	13412	assert_or_panic(v[15] == 905);
	13413	assert_or_panic(v[16] == 906);
	13414	assert_or_panic(v[17] == 907);
	13415	assert_or_panic(v[18] == 908);
	13416	assert_or_panic(v[19] == 909);
	13417	assert_or_panic(v[20] == 910);
	13418	assert_or_panic(v[21] == 911);
	13419	assert_or_panic(v[22] == 912);
	13420	assert_or_panic(v[23] == 913);
	13421	assert_or_panic(v[24] == 914);
	13422	assert_or_panic(v[25] == 915);
	13423	assert_or_panic(v[26] == 916);
	13424	assert_or_panic(v[27] == 917);
	13425	assert_or_panic(v[28] == 918);
	13426	assert_or_panic(v[29] == 919);
	13427	assert_or_panic(v[30] == 920);
	13428	assert_or_panic(v[31] == 921);
	13429	assert_or_panic(v[32] == 922);
	13430	assert_or_panic(v[33] == 923);
	13431	assert_or_panic(v[34] == 924);
	13432	assert_or_panic(v[35] == 925);
	13433	assert_or_panic(v[36] == 926);
	13434	assert_or_panic(v[37] == 927);
	13435	assert_or_panic(v[38] == 928);
	13436	assert_or_panic(v[39] == 929);
	13437	assert_or_panic(v[40] == 930);
	13438	assert_or_panic(v[41] == 931);
	13439	assert_or_panic(v[42] == 932);
	13440	assert_or_panic(v[43] == 933);
	13441	assert_or_panic(v[44] == 934);
	13442	assert_or_panic(v[45] == 935);
	13443	assert_or_panic(v[46] == 936);
	13444	assert_or_panic(v[47] == 937);
	13445	assert_or_panic(v[48] == 938);
	13446	assert_or_panic(v[49] == 939);
	13447	assert_or_panic(v[50] == 940);
	13448	assert_or_panic(v[51] == 941);
	13449	assert_or_panic(v[52] == 942);
	13450	assert_or_panic(v[53] == 943);
	13451	assert_or_panic(v[54] == 944);
	13452	assert_or_panic(v[55] == 945);
	13453	assert_or_panic(v[56] == 946);
	13454	assert_or_panic(v[57] == 947);
	13455	assert_or_panic(v[58] == 948);
	13456	assert_or_panic(v[59] == 949);
	13457	assert_or_panic(v[60] == 950);
	13458	assert_or_panic(v[61] == 951);
	13459	assert_or_panic(v[62] == 952);
	13460	assert_or_panic(v[63] == 953);
	13461	assert_or_panic(v[64] == 954);
	13462	assert_or_panic(v[65] == 955);
	13463	assert_or_panic(v[66] == 956);
	13464	assert_or_panic(v[67] == 957);
	13465	assert_or_panic(v[68] == 958);
	13466	assert_or_panic(v[69] == 959);
	13467	assert_or_panic(v[70] == 960);
	13468	assert_or_panic(v[71] == 961);
	13469	assert_or_panic(v[72] == 962);
	13470	assert_or_panic(v[73] == 963);
	13471	assert_or_panic(v[74] == 964);
	13472	assert_or_panic(v[75] == 965);
	13473	assert_or_panic(v[76] == 966);
	13474	assert_or_panic(v[77] == 967);
	13475	assert_or_panic(v[78] == 968);
	13476	assert_or_panic(v[79] == 969);
	13477	assert_or_panic(v[80] == 970);
	13478	assert_or_panic(v[81] == 971);
	13479	assert_or_panic(v[82] == 972);
	13480	assert_or_panic(v[83] == 973);
	13481	assert_or_panic(v[84] == 974);
	13482	assert_or_panic(v[85] == 975);
	13483	assert_or_panic(v[86] == 976);
	13484	assert_or_panic(v[87] == 977);
	13485	assert_or_panic(v[88] == 978);
	13486	assert_or_panic(v[89] == 979);
	13487	assert_or_panic(v[90] == 980);
	13488	assert_or_panic(v[91] == 981);
	13489	assert_or_panic(v[92] == 982);
	13490	assert_or_panic(v[93] == 983);
	13491	assert_or_panic(v[94] == 984);
	13492	assert_or_panic(v[95] == 985);
	13493	zig_vector_96_f32((Vector_96_f32){
	13494	986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001,
	13495	1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017,
	13496	1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033,
	13497	1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049,
	13498	1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065,
	13499	1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081,
	13500	}, 96);
	13501	}
	13502
	13503	typedef float Vector_128_f32 __attribute__((vector_size(128 * sizeof(float))));
	13504
	13505	Vector_128_f32 zig_ret_vector_128_f32(void);
	13506	void zig_vector_128_f32(Vector_128_f32, size_t);
	13507
	13508	Vector_128_f32 c_ret_vector_128_f32(void) {
	13509	return (Vector_128_f32){
	13510	1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545,
	13511	1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561,
	13512	1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577,
	13513	1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593,
	13514	1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609,
	13515	1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625,
	13516	1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641,
	13517	1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657,
	13518	};
	13519	}
	13520	void c_vector_128_f32(Vector_128_f32 v, size_t i) {
	13521	assert_or_panic(v[0] == 1658);
	13522	assert_or_panic(v[1] == 1659);
	13523	assert_or_panic(v[2] == 1660);
	13524	assert_or_panic(v[3] == 1661);
	13525	assert_or_panic(v[4] == 1662);
	13526	assert_or_panic(v[5] == 1663);
	13527	assert_or_panic(v[6] == 1664);
	13528	assert_or_panic(v[7] == 1665);
	13529	assert_or_panic(v[8] == 1666);
	13530	assert_or_panic(v[9] == 1667);
	13531	assert_or_panic(v[10] == 1668);
	13532	assert_or_panic(v[11] == 1669);
	13533	assert_or_panic(v[12] == 1670);
	13534	assert_or_panic(v[13] == 1671);
	13535	assert_or_panic(v[14] == 1672);
	13536	assert_or_panic(v[15] == 1673);
	13537	assert_or_panic(v[16] == 1674);
	13538	assert_or_panic(v[17] == 1675);
	13539	assert_or_panic(v[18] == 1676);
	13540	assert_or_panic(v[19] == 1677);
	13541	assert_or_panic(v[20] == 1678);
	13542	assert_or_panic(v[21] == 1679);
	13543	assert_or_panic(v[22] == 1680);
	13544	assert_or_panic(v[23] == 1681);
	13545	assert_or_panic(v[24] == 1682);
	13546	assert_or_panic(v[25] == 1683);
	13547	assert_or_panic(v[26] == 1684);
	13548	assert_or_panic(v[27] == 1685);
	13549	assert_or_panic(v[28] == 1686);
	13550	assert_or_panic(v[29] == 1687);
	13551	assert_or_panic(v[30] == 1688);
	13552	assert_or_panic(v[31] == 1689);
	13553	assert_or_panic(v[32] == 1690);
	13554	assert_or_panic(v[33] == 1691);
	13555	assert_or_panic(v[34] == 1692);
	13556	assert_or_panic(v[35] == 1693);
	13557	assert_or_panic(v[36] == 1694);
	13558	assert_or_panic(v[37] == 1695);
	13559	assert_or_panic(v[38] == 1696);
	13560	assert_or_panic(v[39] == 1697);
	13561	assert_or_panic(v[40] == 1698);
	13562	assert_or_panic(v[41] == 1699);
	13563	assert_or_panic(v[42] == 1700);
	13564	assert_or_panic(v[43] == 1701);
	13565	assert_or_panic(v[44] == 1702);
	13566	assert_or_panic(v[45] == 1703);
	13567	assert_or_panic(v[46] == 1704);
	13568	assert_or_panic(v[47] == 1705);
	13569	assert_or_panic(v[48] == 1706);
	13570	assert_or_panic(v[49] == 1707);
	13571	assert_or_panic(v[50] == 1708);
	13572	assert_or_panic(v[51] == 1709);
	13573	assert_or_panic(v[52] == 1710);
	13574	assert_or_panic(v[53] == 1711);
	13575	assert_or_panic(v[54] == 1712);
	13576	assert_or_panic(v[55] == 1713);
	13577	assert_or_panic(v[56] == 1714);
	13578	assert_or_panic(v[57] == 1715);
	13579	assert_or_panic(v[58] == 1716);
	13580	assert_or_panic(v[59] == 1717);
	13581	assert_or_panic(v[60] == 1718);
	13582	assert_or_panic(v[61] == 1719);
	13583	assert_or_panic(v[62] == 1720);
	13584	assert_or_panic(v[63] == 1721);
	13585	assert_or_panic(v[64] == 1722);
	13586	assert_or_panic(v[65] == 1723);
	13587	assert_or_panic(v[66] == 1724);
	13588	assert_or_panic(v[67] == 1725);
	13589	assert_or_panic(v[68] == 1726);
	13590	assert_or_panic(v[69] == 1727);
	13591	assert_or_panic(v[70] == 1728);
	13592	assert_or_panic(v[71] == 1729);
	13593	assert_or_panic(v[72] == 1730);
	13594	assert_or_panic(v[73] == 1731);
	13595	assert_or_panic(v[74] == 1732);
	13596	assert_or_panic(v[75] == 1733);
	13597	assert_or_panic(v[76] == 1734);
	13598	assert_or_panic(v[77] == 1735);
	13599	assert_or_panic(v[78] == 1736);
	13600	assert_or_panic(v[79] == 1737);
	13601	assert_or_panic(v[80] == 1738);
	13602	assert_or_panic(v[81] == 1739);
	13603	assert_or_panic(v[82] == 1740);
	13604	assert_or_panic(v[83] == 1741);
	13605	assert_or_panic(v[84] == 1742);
	13606	assert_or_panic(v[85] == 1743);
	13607	assert_or_panic(v[86] == 1744);
	13608	assert_or_panic(v[87] == 1745);
	13609	assert_or_panic(v[88] == 1746);
	13610	assert_or_panic(v[89] == 1747);
	13611	assert_or_panic(v[90] == 1748);
	13612	assert_or_panic(v[91] == 1749);
	13613	assert_or_panic(v[92] == 1750);
	13614	assert_or_panic(v[93] == 1751);
	13615	assert_or_panic(v[94] == 1752);
	13616	assert_or_panic(v[95] == 1753);
	13617	assert_or_panic(v[96] == 1754);
	13618	assert_or_panic(v[97] == 1755);
	13619	assert_or_panic(v[98] == 1756);
	13620	assert_or_panic(v[99] == 1757);
	13621	assert_or_panic(v[100] == 1758);
	13622	assert_or_panic(v[101] == 1759);
	13623	assert_or_panic(v[102] == 1760);
	13624	assert_or_panic(v[103] == 1761);
	13625	assert_or_panic(v[104] == 1762);
	13626	assert_or_panic(v[105] == 1763);
	13627	assert_or_panic(v[106] == 1764);
	13628	assert_or_panic(v[107] == 1765);
	13629	assert_or_panic(v[108] == 1766);
	13630	assert_or_panic(v[109] == 1767);
	13631	assert_or_panic(v[110] == 1768);
	13632	assert_or_panic(v[111] == 1769);
	13633	assert_or_panic(v[112] == 1770);
	13634	assert_or_panic(v[113] == 1771);
	13635	assert_or_panic(v[114] == 1772);
	13636	assert_or_panic(v[115] == 1773);
	13637	assert_or_panic(v[116] == 1774);
	13638	assert_or_panic(v[117] == 1775);
	13639	assert_or_panic(v[118] == 1776);
	13640	assert_or_panic(v[119] == 1777);
	13641	assert_or_panic(v[120] == 1778);
	13642	assert_or_panic(v[121] == 1779);
	13643	assert_or_panic(v[122] == 1780);
	13644	assert_or_panic(v[123] == 1781);
	13645	assert_or_panic(v[124] == 1782);
	13646	assert_or_panic(v[125] == 1783);
	13647	assert_or_panic(v[126] == 1784);
	13648	assert_or_panic(v[127] == 1785);
	13649	assert_or_panic(i == 128);
	13650	}
	13651	void c_test_vector_128_f32(void) {
	13652	Vector_128_f32 v = zig_ret_vector_128_f32();
	13653	assert_or_panic(v[0] == 1274);
	13654	assert_or_panic(v[1] == 1275);
	13655	assert_or_panic(v[2] == 1276);
	13656	assert_or_panic(v[3] == 1277);
	13657	assert_or_panic(v[4] == 1278);
	13658	assert_or_panic(v[5] == 1279);
	13659	assert_or_panic(v[6] == 1280);
	13660	assert_or_panic(v[7] == 1281);
	13661	assert_or_panic(v[8] == 1282);
	13662	assert_or_panic(v[9] == 1283);
	13663	assert_or_panic(v[10] == 1284);
	13664	assert_or_panic(v[11] == 1285);
	13665	assert_or_panic(v[12] == 1286);
	13666	assert_or_panic(v[13] == 1287);
	13667	assert_or_panic(v[14] == 1288);
	13668	assert_or_panic(v[15] == 1289);
	13669	assert_or_panic(v[16] == 1290);
	13670	assert_or_panic(v[17] == 1291);
	13671	assert_or_panic(v[18] == 1292);
	13672	assert_or_panic(v[19] == 1293);
	13673	assert_or_panic(v[20] == 1294);
	13674	assert_or_panic(v[21] == 1295);
	13675	assert_or_panic(v[22] == 1296);
	13676	assert_or_panic(v[23] == 1297);
	13677	assert_or_panic(v[24] == 1298);
	13678	assert_or_panic(v[25] == 1299);
	13679	assert_or_panic(v[26] == 1300);
	13680	assert_or_panic(v[27] == 1301);
	13681	assert_or_panic(v[28] == 1302);
	13682	assert_or_panic(v[29] == 1303);
	13683	assert_or_panic(v[30] == 1304);
	13684	assert_or_panic(v[31] == 1305);
	13685	assert_or_panic(v[32] == 1306);
	13686	assert_or_panic(v[33] == 1307);
	13687	assert_or_panic(v[34] == 1308);
	13688	assert_or_panic(v[35] == 1309);
	13689	assert_or_panic(v[36] == 1310);
	13690	assert_or_panic(v[37] == 1311);
	13691	assert_or_panic(v[38] == 1312);
	13692	assert_or_panic(v[39] == 1313);
	13693	assert_or_panic(v[40] == 1314);
	13694	assert_or_panic(v[41] == 1315);
	13695	assert_or_panic(v[42] == 1316);
	13696	assert_or_panic(v[43] == 1317);
	13697	assert_or_panic(v[44] == 1318);
	13698	assert_or_panic(v[45] == 1319);
	13699	assert_or_panic(v[46] == 1320);
	13700	assert_or_panic(v[47] == 1321);
	13701	assert_or_panic(v[48] == 1322);
	13702	assert_or_panic(v[49] == 1323);
	13703	assert_or_panic(v[50] == 1324);
	13704	assert_or_panic(v[51] == 1325);
	13705	assert_or_panic(v[52] == 1326);
	13706	assert_or_panic(v[53] == 1327);
	13707	assert_or_panic(v[54] == 1328);
	13708	assert_or_panic(v[55] == 1329);
	13709	assert_or_panic(v[56] == 1330);
	13710	assert_or_panic(v[57] == 1331);
	13711	assert_or_panic(v[58] == 1332);
	13712	assert_or_panic(v[59] == 1333);
	13713	assert_or_panic(v[60] == 1334);
	13714	assert_or_panic(v[61] == 1335);
	13715	assert_or_panic(v[62] == 1336);
	13716	assert_or_panic(v[63] == 1337);
	13717	assert_or_panic(v[64] == 1338);
	13718	assert_or_panic(v[65] == 1339);
	13719	assert_or_panic(v[66] == 1340);
	13720	assert_or_panic(v[67] == 1341);
	13721	assert_or_panic(v[68] == 1342);
	13722	assert_or_panic(v[69] == 1343);
	13723	assert_or_panic(v[70] == 1344);
	13724	assert_or_panic(v[71] == 1345);
	13725	assert_or_panic(v[72] == 1346);
	13726	assert_or_panic(v[73] == 1347);
	13727	assert_or_panic(v[74] == 1348);
	13728	assert_or_panic(v[75] == 1349);
	13729	assert_or_panic(v[76] == 1350);
	13730	assert_or_panic(v[77] == 1351);
	13731	assert_or_panic(v[78] == 1352);
	13732	assert_or_panic(v[79] == 1353);
	13733	assert_or_panic(v[80] == 1354);
	13734	assert_or_panic(v[81] == 1355);
	13735	assert_or_panic(v[82] == 1356);
	13736	assert_or_panic(v[83] == 1357);
	13737	assert_or_panic(v[84] == 1358);
	13738	assert_or_panic(v[85] == 1359);
	13739	assert_or_panic(v[86] == 1360);
	13740	assert_or_panic(v[87] == 1361);
	13741	assert_or_panic(v[88] == 1362);
	13742	assert_or_panic(v[89] == 1363);
	13743	assert_or_panic(v[90] == 1364);
	13744	assert_or_panic(v[91] == 1365);
	13745	assert_or_panic(v[92] == 1366);
	13746	assert_or_panic(v[93] == 1367);
	13747	assert_or_panic(v[94] == 1368);
	13748	assert_or_panic(v[95] == 1369);
	13749	assert_or_panic(v[96] == 1370);
	13750	assert_or_panic(v[97] == 1371);
	13751	assert_or_panic(v[98] == 1372);
	13752	assert_or_panic(v[99] == 1373);
	13753	assert_or_panic(v[100] == 1374);
	13754	assert_or_panic(v[101] == 1375);
	13755	assert_or_panic(v[102] == 1376);
	13756	assert_or_panic(v[103] == 1377);
	13757	assert_or_panic(v[104] == 1378);
	13758	assert_or_panic(v[105] == 1379);
	13759	assert_or_panic(v[106] == 1380);
	13760	assert_or_panic(v[107] == 1381);
	13761	assert_or_panic(v[108] == 1382);
	13762	assert_or_panic(v[109] == 1383);
	13763	assert_or_panic(v[110] == 1384);
	13764	assert_or_panic(v[111] == 1385);
	13765	assert_or_panic(v[112] == 1386);
	13766	assert_or_panic(v[113] == 1387);
	13767	assert_or_panic(v[114] == 1388);
	13768	assert_or_panic(v[115] == 1389);
	13769	assert_or_panic(v[116] == 1390);
	13770	assert_or_panic(v[117] == 1391);
	13771	assert_or_panic(v[118] == 1392);
	13772	assert_or_panic(v[119] == 1393);
	13773	assert_or_panic(v[120] == 1394);
	13774	assert_or_panic(v[121] == 1395);
	13775	assert_or_panic(v[122] == 1396);
	13776	assert_or_panic(v[123] == 1397);
	13777	assert_or_panic(v[124] == 1398);
	13778	assert_or_panic(v[125] == 1399);
	13779	assert_or_panic(v[126] == 1400);
	13780	assert_or_panic(v[127] == 1401);
	13781	zig_vector_128_f32((Vector_128_f32){
	13782	1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417,
	13783	1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433,
	13784	1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449,
	13785	1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465,
	13786	1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481,
	13787	1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497,
	13788	1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513,
	13789	1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529,
	13790	}, 128);
	13791	}
	13792
	13793	typedef double Vector_1_f64 __attribute__((vector_size(1 * sizeof(double))));
	13794
	13795	Vector_1_f64 zig_ret_vector_1_f64(void);
	13796	void zig_vector_1_f64(Vector_1_f64, size_t);
	13797
	13798	Vector_1_f64 c_ret_vector_1_f64(void) {
	13799	return (Vector_1_f64){ 3 };
	13800	}
	13801	void c_vector_1_f64(Vector_1_f64 v, size_t i) {
	13802	assert_or_panic(v[0] == 4);
	13803	assert_or_panic(i == 1);
	13804	}
	13805	void c_test_vector_1_f64(void) {
	13806	Vector_1_f64 v = zig_ret_vector_1_f64();
	13807	assert_or_panic(v[0] == 1);
	13808	zig_vector_1_f64((Vector_1_f64){ 2 }, 1);
	13809	}
	13810
	13811	typedef double Vector_2_f64 __attribute__((vector_size(2 * sizeof(double))));
	13812
	13813	Vector_2_f64 zig_ret_vector_2_f64(void);
	13814	void zig_vector_2_f64(Vector_2_f64, size_t);
	13815
	13816	Vector_2_f64 c_ret_vector_2_f64(void) {
	13817	return (Vector_2_f64){ 9, 10 };
	13818	}
	13819	void c_vector_2_f64(Vector_2_f64 v, size_t i) {
	13820	assert_or_panic(v[0] == 11);
	13821	assert_or_panic(v[1] == 12);
	13822	assert_or_panic(i == 2);
	13823	}
	13824	void c_test_vector_2_f64(void) {
	13825	Vector_2_f64 v = zig_ret_vector_2_f64();
	13826	assert_or_panic(v[0] == 5);
	13827	assert_or_panic(v[1] == 6);
	13828	zig_vector_2_f64((Vector_2_f64){ 7, 8 }, 2);
	13829	}
	13830
	13831	typedef double Vector_3_f64 __attribute__((vector_size(3 * sizeof(double))));
	13832
	13833	Vector_3_f64 zig_ret_vector_3_f64(void);
	13834	void zig_vector_3_f64(Vector_3_f64, size_t);
	13835
	13836	Vector_3_f64 c_ret_vector_3_f64(void) {
	13837	return (Vector_3_f64){ 19, 20, 21 };
	13838	}
	13839	void c_vector_3_f64(Vector_3_f64 v, size_t i) {
	13840	assert_or_panic(v[0] == 22);
	13841	assert_or_panic(v[1] == 23);
	13842	assert_or_panic(v[2] == 24);
	13843	assert_or_panic(i == 3);
	13844	}
	13845	void c_test_vector_3_f64(void) {
	13846	Vector_3_f64 v = zig_ret_vector_3_f64();
	13847	assert_or_panic(v[0] == 13);
	13848	assert_or_panic(v[1] == 14);
	13849	assert_or_panic(v[2] == 15);
	13850	zig_vector_3_f64((Vector_3_f64){ 16, 17, 18 }, 3);
	13851	}
	13852
	13853	typedef double Vector_4_f64 __attribute__((vector_size(4 * sizeof(double))));
	13854
	13855	Vector_4_f64 zig_ret_vector_4_f64(void);
	13856	void zig_vector_4_f64(Vector_4_f64, size_t);
	13857
	13858	Vector_4_f64 c_ret_vector_4_f64(void) {
	13859	return (Vector_4_f64){ 33, 34, 35, 36 };
	13860	}
	13861	void c_vector_4_f64(Vector_4_f64 v, size_t i) {
	13862	assert_or_panic(v[0] == 37);
	13863	assert_or_panic(v[1] == 38);
	13864	assert_or_panic(v[2] == 39);
	13865	assert_or_panic(v[3] == 40);
	13866	assert_or_panic(i == 4);
	13867	}
	13868	void c_test_vector_4_f64(void) {
	13869	Vector_4_f64 v = zig_ret_vector_4_f64();
	13870	assert_or_panic(v[0] == 25);
	13871	assert_or_panic(v[1] == 26);
	13872	assert_or_panic(v[2] == 27);
	13873	assert_or_panic(v[3] == 28);
	13874	zig_vector_4_f64((Vector_4_f64){ 29, 30, 31, 32 }, 4);
	13875	}
	13876
	13877	typedef double Vector_6_f64 __attribute__((vector_size(6 * sizeof(double))));
	13878
	13879	Vector_6_f64 zig_ret_vector_6_f64(void);
	13880	void zig_vector_6_f64(Vector_6_f64, size_t);
	13881
	13882	Vector_6_f64 c_ret_vector_6_f64(void) {
	13883	return (Vector_6_f64){ 53, 54, 55, 56, 57, 58 };
	13884	}
	13885	void c_vector_6_f64(Vector_6_f64 v, size_t i) {
	13886	assert_or_panic(v[0] == 59);
	13887	assert_or_panic(v[1] == 60);
	13888	assert_or_panic(v[2] == 61);
	13889	assert_or_panic(v[3] == 62);
	13890	assert_or_panic(v[4] == 63);
	13891	assert_or_panic(v[5] == 64);
	13892	assert_or_panic(i == 6);
	13893	}
	13894	void c_test_vector_6_f64(void) {
	13895	Vector_6_f64 v = zig_ret_vector_6_f64();
	13896	assert_or_panic(v[0] == 41);
	13897	assert_or_panic(v[1] == 42);
	13898	assert_or_panic(v[2] == 43);
	13899	assert_or_panic(v[3] == 44);
	13900	assert_or_panic(v[4] == 45);
	13901	assert_or_panic(v[5] == 46);
	13902	zig_vector_6_f64((Vector_6_f64){ 47, 48, 49, 50, 51, 52 }, 6);
	13903	}
	13904
	13905	typedef double Vector_8_f64 __attribute__((vector_size(8 * sizeof(double))));
	13906
	13907	Vector_8_f64 zig_ret_vector_8_f64(void);
	13908	void zig_vector_8_f64(Vector_8_f64, size_t);
	13909
	13910	Vector_8_f64 c_ret_vector_8_f64(void) {
	13911	return (Vector_8_f64){ 81, 82, 83, 84, 85, 86, 87, 88 };
	13912	}
	13913	void c_vector_8_f64(Vector_8_f64 v, size_t i) {
	13914	assert_or_panic(v[0] == 89);
	13915	assert_or_panic(v[1] == 90);
	13916	assert_or_panic(v[2] == 91);
	13917	assert_or_panic(v[3] == 92);
	13918	assert_or_panic(v[4] == 93);
	13919	assert_or_panic(v[5] == 94);
	13920	assert_or_panic(v[6] == 95);
	13921	assert_or_panic(v[7] == 96);
	13922	assert_or_panic(i == 8);
	13923	}
	13924	void c_test_vector_8_f64(void) {
	13925	Vector_8_f64 v = zig_ret_vector_8_f64();
	13926	assert_or_panic(v[0] == 65);
	13927	assert_or_panic(v[1] == 66);
	13928	assert_or_panic(v[2] == 67);
	13929	assert_or_panic(v[3] == 68);
	13930	assert_or_panic(v[4] == 69);
	13931	assert_or_panic(v[5] == 70);
	13932	assert_or_panic(v[6] == 71);
	13933	assert_or_panic(v[7] == 72);
	13934	zig_vector_8_f64((Vector_8_f64){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8);
	13935	}
	13936
	13937	typedef double Vector_12_f64 __attribute__((vector_size(12 * sizeof(double))));
	13938
	13939	Vector_12_f64 zig_ret_vector_12_f64(void);
	13940	void zig_vector_12_f64(Vector_12_f64, size_t);
	13941
	13942	Vector_12_f64 c_ret_vector_12_f64(void) {
	13943	return (Vector_12_f64){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 };
	13944	}
	13945	void c_vector_12_f64(Vector_12_f64 v, size_t i) {
	13946	assert_or_panic(v[0] == 133);
	13947	assert_or_panic(v[1] == 134);
	13948	assert_or_panic(v[2] == 135);
	13949	assert_or_panic(v[3] == 136);
	13950	assert_or_panic(v[4] == 137);
	13951	assert_or_panic(v[5] == 138);
	13952	assert_or_panic(v[6] == 139);
	13953	assert_or_panic(v[7] == 140);
	13954	assert_or_panic(v[8] == 141);
	13955	assert_or_panic(v[9] == 142);
	13956	assert_or_panic(v[10] == 143);
	13957	assert_or_panic(v[11] == 144);
	13958	assert_or_panic(i == 12);
	13959	}
	13960	void c_test_vector_12_f64(void) {
	13961	Vector_12_f64 v = zig_ret_vector_12_f64();
	13962	assert_or_panic(v[0] == 97);
	13963	assert_or_panic(v[1] == 98);
	13964	assert_or_panic(v[2] == 99);
	13965	assert_or_panic(v[3] == 100);
	13966	assert_or_panic(v[4] == 101);
	13967	assert_or_panic(v[5] == 102);
	13968	assert_or_panic(v[6] == 103);
	13969	assert_or_panic(v[7] == 104);
	13970	assert_or_panic(v[8] == 105);
	13971	assert_or_panic(v[9] == 106);
	13972	assert_or_panic(v[10] == 107);
	13973	assert_or_panic(v[11] == 108);
	13974	zig_vector_12_f64((Vector_12_f64){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12);
	13975	}
	13976
	13977	typedef double Vector_16_f64 __attribute__((vector_size(16 * sizeof(double))));
	13978
	13979	Vector_16_f64 zig_ret_vector_16_f64(void);
	13980	void zig_vector_16_f64(Vector_16_f64, size_t);
	13981
	13982	Vector_16_f64 c_ret_vector_16_f64(void) {
	13983	return (Vector_16_f64){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 };
	13984	}
	13985	void c_vector_16_f64(Vector_16_f64 v, size_t i) {
	13986	assert_or_panic(v[0] == 193);
	13987	assert_or_panic(v[1] == 194);
	13988	assert_or_panic(v[2] == 195);
	13989	assert_or_panic(v[3] == 196);
	13990	assert_or_panic(v[4] == 197);
	13991	assert_or_panic(v[5] == 198);
	13992	assert_or_panic(v[6] == 199);
	13993	assert_or_panic(v[7] == 200);
	13994	assert_or_panic(v[8] == 201);
	13995	assert_or_panic(v[9] == 202);
	13996	assert_or_panic(v[10] == 203);
	13997	assert_or_panic(v[11] == 204);
	13998	assert_or_panic(v[12] == 205);
	13999	assert_or_panic(v[13] == 206);
	14000	assert_or_panic(v[14] == 207);
	14001	assert_or_panic(v[15] == 208);
	14002	assert_or_panic(i == 16);
	14003	}
	14004	void c_test_vector_16_f64(void) {
	14005	Vector_16_f64 v = zig_ret_vector_16_f64();
	14006	assert_or_panic(v[0] == 145);
	14007	assert_or_panic(v[1] == 146);
	14008	assert_or_panic(v[2] == 147);
	14009	assert_or_panic(v[3] == 148);
	14010	assert_or_panic(v[4] == 149);
	14011	assert_or_panic(v[5] == 150);
	14012	assert_or_panic(v[6] == 151);
	14013	assert_or_panic(v[7] == 152);
	14014	assert_or_panic(v[8] == 153);
	14015	assert_or_panic(v[9] == 154);
	14016	assert_or_panic(v[10] == 155);
	14017	assert_or_panic(v[11] == 156);
	14018	assert_or_panic(v[12] == 157);
	14019	assert_or_panic(v[13] == 158);
	14020	assert_or_panic(v[14] == 159);
	14021	assert_or_panic(v[15] == 160);
	14022	zig_vector_16_f64((Vector_16_f64){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16);
	14023	}
	14024
	14025	typedef double Vector_24_f64 __attribute__((vector_size(24 * sizeof(double))));
	14026
	14027	Vector_24_f64 zig_ret_vector_24_f64(void);
	14028	void zig_vector_24_f64(Vector_24_f64, size_t);
	14029
	14030	Vector_24_f64 c_ret_vector_24_f64(void) {
	14031	return (Vector_24_f64){
	14032	257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
	14033	273, 274, 275, 276, 277, 278, 279, 280,
	14034	};
	14035	}
	14036	void c_vector_24_f64(Vector_24_f64 v, size_t i) {
	14037	assert_or_panic(v[0] == 281);
	14038	assert_or_panic(v[1] == 282);
	14039	assert_or_panic(v[2] == 283);
	14040	assert_or_panic(v[3] == 284);
	14041	assert_or_panic(v[4] == 285);
	14042	assert_or_panic(v[5] == 286);
	14043	assert_or_panic(v[6] == 287);
	14044	assert_or_panic(v[7] == 288);
	14045	assert_or_panic(v[8] == 289);
	14046	assert_or_panic(v[9] == 290);
	14047	assert_or_panic(v[10] == 291);
	14048	assert_or_panic(v[11] == 292);
	14049	assert_or_panic(v[12] == 293);
	14050	assert_or_panic(v[13] == 294);
	14051	assert_or_panic(v[14] == 295);
	14052	assert_or_panic(v[15] == 296);
	14053	assert_or_panic(v[16] == 297);
	14054	assert_or_panic(v[17] == 298);
	14055	assert_or_panic(v[18] == 299);
	14056	assert_or_panic(v[19] == 300);
	14057	assert_or_panic(v[20] == 301);
	14058	assert_or_panic(v[21] == 302);
	14059	assert_or_panic(v[22] == 303);
	14060	assert_or_panic(v[23] == 304);
	14061	assert_or_panic(i == 24);
	14062	}
	14063	void c_test_vector_24_f64(void) {
	14064	Vector_24_f64 v = zig_ret_vector_24_f64();
	14065	assert_or_panic(v[0] == 209);
	14066	assert_or_panic(v[1] == 210);
	14067	assert_or_panic(v[2] == 211);
	14068	assert_or_panic(v[3] == 212);
	14069	assert_or_panic(v[4] == 213);
	14070	assert_or_panic(v[5] == 214);
	14071	assert_or_panic(v[6] == 215);
	14072	assert_or_panic(v[7] == 216);
	14073	assert_or_panic(v[8] == 217);
	14074	assert_or_panic(v[9] == 218);
	14075	assert_or_panic(v[10] == 219);
	14076	assert_or_panic(v[11] == 220);
	14077	assert_or_panic(v[12] == 221);
	14078	assert_or_panic(v[13] == 222);
	14079	assert_or_panic(v[14] == 223);
	14080	assert_or_panic(v[15] == 224);
	14081	assert_or_panic(v[16] == 225);
	14082	assert_or_panic(v[17] == 226);
	14083	assert_or_panic(v[18] == 227);
	14084	assert_or_panic(v[19] == 228);
	14085	assert_or_panic(v[20] == 229);
	14086	assert_or_panic(v[21] == 230);
	14087	assert_or_panic(v[22] == 231);
	14088	assert_or_panic(v[23] == 232);
	14089	zig_vector_24_f64((Vector_24_f64){
	14090	233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
	14091	249, 250, 251, 252, 253, 254, 255, 256,
	14092	}, 24);
	14093	}
	14094
	14095	typedef double Vector_32_f64 __attribute__((vector_size(32 * sizeof(double))));
	14096
	14097	Vector_32_f64 zig_ret_vector_32_f64(void);
	14098	void zig_vector_32_f64(Vector_32_f64, size_t);
	14099
	14100	Vector_32_f64 c_ret_vector_32_f64(void) {
	14101	return (Vector_32_f64){
	14102	369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
	14103	385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400,
	14104	};
	14105	}
	14106	void c_vector_32_f64(Vector_32_f64 v, size_t i) {
	14107	assert_or_panic(v[0] == 401);
	14108	assert_or_panic(v[1] == 402);
	14109	assert_or_panic(v[2] == 403);
	14110	assert_or_panic(v[3] == 404);
	14111	assert_or_panic(v[4] == 405);
	14112	assert_or_panic(v[5] == 406);
	14113	assert_or_panic(v[6] == 407);
	14114	assert_or_panic(v[7] == 408);
	14115	assert_or_panic(v[8] == 409);
	14116	assert_or_panic(v[9] == 410);
	14117	assert_or_panic(v[10] == 411);
	14118	assert_or_panic(v[11] == 412);
	14119	assert_or_panic(v[12] == 413);
	14120	assert_or_panic(v[13] == 414);
	14121	assert_or_panic(v[14] == 415);
	14122	assert_or_panic(v[15] == 416);
	14123	assert_or_panic(v[16] == 417);
	14124	assert_or_panic(v[17] == 418);
	14125	assert_or_panic(v[18] == 419);
	14126	assert_or_panic(v[19] == 420);
	14127	assert_or_panic(v[20] == 421);
	14128	assert_or_panic(v[21] == 422);
	14129	assert_or_panic(v[22] == 423);
	14130	assert_or_panic(v[23] == 424);
	14131	assert_or_panic(v[24] == 425);
	14132	assert_or_panic(v[25] == 426);
	14133	assert_or_panic(v[26] == 427);
	14134	assert_or_panic(v[27] == 428);
	14135	assert_or_panic(v[28] == 429);
	14136	assert_or_panic(v[29] == 430);
	14137	assert_or_panic(v[30] == 431);
	14138	assert_or_panic(v[31] == 432);
	14139	assert_or_panic(i == 32);
	14140	}
	14141	void c_test_vector_32_f64(void) {
	14142	Vector_32_f64 v = zig_ret_vector_32_f64();
	14143	assert_or_panic(v[0] == 305);
	14144	assert_or_panic(v[1] == 306);
	14145	assert_or_panic(v[2] == 307);
	14146	assert_or_panic(v[3] == 308);
	14147	assert_or_panic(v[4] == 309);
	14148	assert_or_panic(v[5] == 310);
	14149	assert_or_panic(v[6] == 311);
	14150	assert_or_panic(v[7] == 312);
	14151	assert_or_panic(v[8] == 313);
	14152	assert_or_panic(v[9] == 314);
	14153	assert_or_panic(v[10] == 315);
	14154	assert_or_panic(v[11] == 316);
	14155	assert_or_panic(v[12] == 317);
	14156	assert_or_panic(v[13] == 318);
	14157	assert_or_panic(v[14] == 319);
	14158	assert_or_panic(v[15] == 320);
	14159	assert_or_panic(v[16] == 321);
	14160	assert_or_panic(v[17] == 322);
	14161	assert_or_panic(v[18] == 323);
	14162	assert_or_panic(v[19] == 324);
	14163	assert_or_panic(v[20] == 325);
	14164	assert_or_panic(v[21] == 326);
	14165	assert_or_panic(v[22] == 327);
	14166	assert_or_panic(v[23] == 328);
	14167	assert_or_panic(v[24] == 329);
	14168	assert_or_panic(v[25] == 330);
	14169	assert_or_panic(v[26] == 331);
	14170	assert_or_panic(v[27] == 332);
	14171	assert_or_panic(v[28] == 333);
	14172	assert_or_panic(v[29] == 334);
	14173	assert_or_panic(v[30] == 335);
	14174	assert_or_panic(v[31] == 336);
	14175	zig_vector_32_f64((Vector_32_f64){
	14176	337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
	14177	353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
	14178	}, 32);
	14179	}
	14180
	14181	typedef double Vector_48_f64 __attribute__((vector_size(48 * sizeof(double))));
	14182
	14183	Vector_48_f64 zig_ret_vector_48_f64(void);
	14184	void zig_vector_48_f64(Vector_48_f64, size_t);
	14185
	14186	Vector_48_f64 c_ret_vector_48_f64(void) {
	14187	return (Vector_48_f64){
	14188	529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544,
	14189	545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560,
	14190	561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576,
	14191	};
	14192	}
	14193	void c_vector_48_f64(Vector_48_f64 v, size_t i) {
	14194	assert_or_panic(v[0] == 577);
	14195	assert_or_panic(v[1] == 578);
	14196	assert_or_panic(v[2] == 579);
	14197	assert_or_panic(v[3] == 580);
	14198	assert_or_panic(v[4] == 581);
	14199	assert_or_panic(v[5] == 582);
	14200	assert_or_panic(v[6] == 583);
	14201	assert_or_panic(v[7] == 584);
	14202	assert_or_panic(v[8] == 585);
	14203	assert_or_panic(v[9] == 586);
	14204	assert_or_panic(v[10] == 587);
	14205	assert_or_panic(v[11] == 588);
	14206	assert_or_panic(v[12] == 589);
	14207	assert_or_panic(v[13] == 590);
	14208	assert_or_panic(v[14] == 591);
	14209	assert_or_panic(v[15] == 592);
	14210	assert_or_panic(v[16] == 593);
	14211	assert_or_panic(v[17] == 594);
	14212	assert_or_panic(v[18] == 595);
	14213	assert_or_panic(v[19] == 596);
	14214	assert_or_panic(v[20] == 597);
	14215	assert_or_panic(v[21] == 598);
	14216	assert_or_panic(v[22] == 599);
	14217	assert_or_panic(v[23] == 600);
	14218	assert_or_panic(v[24] == 601);
	14219	assert_or_panic(v[25] == 602);
	14220	assert_or_panic(v[26] == 603);
	14221	assert_or_panic(v[27] == 604);
	14222	assert_or_panic(v[28] == 605);
	14223	assert_or_panic(v[29] == 606);
	14224	assert_or_panic(v[30] == 607);
	14225	assert_or_panic(v[31] == 608);
	14226	assert_or_panic(v[32] == 609);
	14227	assert_or_panic(v[33] == 610);
	14228	assert_or_panic(v[34] == 611);
	14229	assert_or_panic(v[35] == 612);
	14230	assert_or_panic(v[36] == 613);
	14231	assert_or_panic(v[37] == 614);
	14232	assert_or_panic(v[38] == 615);
	14233	assert_or_panic(v[39] == 616);
	14234	assert_or_panic(v[40] == 617);
	14235	assert_or_panic(v[41] == 618);
	14236	assert_or_panic(v[42] == 619);
	14237	assert_or_panic(v[43] == 620);
	14238	assert_or_panic(v[44] == 621);
	14239	assert_or_panic(v[45] == 622);
	14240	assert_or_panic(v[46] == 623);
	14241	assert_or_panic(v[47] == 624);
	14242	assert_or_panic(i == 48);
	14243	}
	14244	void c_test_vector_48_f64(void) {
	14245	Vector_48_f64 v = zig_ret_vector_48_f64();
	14246	assert_or_panic(v[0] == 433);
	14247	assert_or_panic(v[1] == 434);
	14248	assert_or_panic(v[2] == 435);
	14249	assert_or_panic(v[3] == 436);
	14250	assert_or_panic(v[4] == 437);
	14251	assert_or_panic(v[5] == 438);
	14252	assert_or_panic(v[6] == 439);
	14253	assert_or_panic(v[7] == 440);
	14254	assert_or_panic(v[8] == 441);
	14255	assert_or_panic(v[9] == 442);
	14256	assert_or_panic(v[10] == 443);
	14257	assert_or_panic(v[11] == 444);
	14258	assert_or_panic(v[12] == 445);
	14259	assert_or_panic(v[13] == 446);
	14260	assert_or_panic(v[14] == 447);
	14261	assert_or_panic(v[15] == 448);
	14262	assert_or_panic(v[16] == 449);
	14263	assert_or_panic(v[17] == 450);
	14264	assert_or_panic(v[18] == 451);
	14265	assert_or_panic(v[19] == 452);
	14266	assert_or_panic(v[20] == 453);
	14267	assert_or_panic(v[21] == 454);
	14268	assert_or_panic(v[22] == 455);
	14269	assert_or_panic(v[23] == 456);
	14270	assert_or_panic(v[24] == 457);
	14271	assert_or_panic(v[25] == 458);
	14272	assert_or_panic(v[26] == 459);
	14273	assert_or_panic(v[27] == 460);
	14274	assert_or_panic(v[28] == 461);
	14275	assert_or_panic(v[29] == 462);
	14276	assert_or_panic(v[30] == 463);
	14277	assert_or_panic(v[31] == 464);
	14278	assert_or_panic(v[32] == 465);
	14279	assert_or_panic(v[33] == 466);
	14280	assert_or_panic(v[34] == 467);
	14281	assert_or_panic(v[35] == 468);
	14282	assert_or_panic(v[36] == 469);
	14283	assert_or_panic(v[37] == 470);
	14284	assert_or_panic(v[38] == 471);
	14285	assert_or_panic(v[39] == 472);
	14286	assert_or_panic(v[40] == 473);
	14287	assert_or_panic(v[41] == 474);
	14288	assert_or_panic(v[42] == 475);
	14289	assert_or_panic(v[43] == 476);
	14290	assert_or_panic(v[44] == 477);
	14291	assert_or_panic(v[45] == 478);
	14292	assert_or_panic(v[46] == 479);
	14293	assert_or_panic(v[47] == 480);
	14294	zig_vector_48_f64((Vector_48_f64){
	14295	481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496,
	14296	497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
	14297	513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
	14298	}, 48);
	14299	}
	14300
	14301	typedef double Vector_64_f64 __attribute__((vector_size(64 * sizeof(double))));
	14302
	14303	Vector_64_f64 zig_ret_vector_64_f64(void);
	14304	void zig_vector_64_f64(Vector_64_f64, size_t);
	14305
	14306	Vector_64_f64 c_ret_vector_64_f64(void) {
	14307	return (Vector_64_f64){
	14308	753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768,
	14309	769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784,
	14310	785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800,
	14311	801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816,
2720	14312	};
2721	14313	}
	14314	void c_vector_64_f64(Vector_64_f64 v, size_t i) {
	14315	assert_or_panic(v[0] == 817);
	14316	assert_or_panic(v[1] == 818);
	14317	assert_or_panic(v[2] == 819);
	14318	assert_or_panic(v[3] == 820);
	14319	assert_or_panic(v[4] == 821);
	14320	assert_or_panic(v[5] == 822);
	14321	assert_or_panic(v[6] == 823);
	14322	assert_or_panic(v[7] == 824);
	14323	assert_or_panic(v[8] == 825);
	14324	assert_or_panic(v[9] == 826);
	14325	assert_or_panic(v[10] == 827);
	14326	assert_or_panic(v[11] == 828);
	14327	assert_or_panic(v[12] == 829);
	14328	assert_or_panic(v[13] == 830);
	14329	assert_or_panic(v[14] == 831);
	14330	assert_or_panic(v[15] == 832);
	14331	assert_or_panic(v[16] == 833);
	14332	assert_or_panic(v[17] == 834);
	14333	assert_or_panic(v[18] == 835);
	14334	assert_or_panic(v[19] == 836);
	14335	assert_or_panic(v[20] == 837);
	14336	assert_or_panic(v[21] == 838);
	14337	assert_or_panic(v[22] == 839);
	14338	assert_or_panic(v[23] == 840);
	14339	assert_or_panic(v[24] == 841);
	14340	assert_or_panic(v[25] == 842);
	14341	assert_or_panic(v[26] == 843);
	14342	assert_or_panic(v[27] == 844);
	14343	assert_or_panic(v[28] == 845);
	14344	assert_or_panic(v[29] == 846);
	14345	assert_or_panic(v[30] == 847);
	14346	assert_or_panic(v[31] == 848);
	14347	assert_or_panic(v[32] == 849);
	14348	assert_or_panic(v[33] == 850);
	14349	assert_or_panic(v[34] == 851);
	14350	assert_or_panic(v[35] == 852);
	14351	assert_or_panic(v[36] == 853);
	14352	assert_or_panic(v[37] == 854);
	14353	assert_or_panic(v[38] == 855);
	14354	assert_or_panic(v[39] == 856);
	14355	assert_or_panic(v[40] == 857);
	14356	assert_or_panic(v[41] == 858);
	14357	assert_or_panic(v[42] == 859);
	14358	assert_or_panic(v[43] == 860);
	14359	assert_or_panic(v[44] == 861);
	14360	assert_or_panic(v[45] == 862);
	14361	assert_or_panic(v[46] == 863);
	14362	assert_or_panic(v[47] == 864);
	14363	assert_or_panic(v[48] == 865);
	14364	assert_or_panic(v[49] == 866);
	14365	assert_or_panic(v[50] == 867);
	14366	assert_or_panic(v[51] == 868);
	14367	assert_or_panic(v[52] == 869);
	14368	assert_or_panic(v[53] == 870);
	14369	assert_or_panic(v[54] == 871);
	14370	assert_or_panic(v[55] == 872);
	14371	assert_or_panic(v[56] == 873);
	14372	assert_or_panic(v[57] == 874);
	14373	assert_or_panic(v[58] == 875);
	14374	assert_or_panic(v[59] == 876);
	14375	assert_or_panic(v[60] == 877);
	14376	assert_or_panic(v[61] == 878);
	14377	assert_or_panic(v[62] == 879);
	14378	assert_or_panic(v[63] == 880);
	14379	assert_or_panic(i == 64);
	14380	}
	14381	void c_test_vector_64_f64(void) {
	14382	Vector_64_f64 v = zig_ret_vector_64_f64();
	14383	assert_or_panic(v[0] == 625);
	14384	assert_or_panic(v[1] == 626);
	14385	assert_or_panic(v[2] == 627);
	14386	assert_or_panic(v[3] == 628);
	14387	assert_or_panic(v[4] == 629);
	14388	assert_or_panic(v[5] == 630);
	14389	assert_or_panic(v[6] == 631);
	14390	assert_or_panic(v[7] == 632);
	14391	assert_or_panic(v[8] == 633);
	14392	assert_or_panic(v[9] == 634);
	14393	assert_or_panic(v[10] == 635);
	14394	assert_or_panic(v[11] == 636);
	14395	assert_or_panic(v[12] == 637);
	14396	assert_or_panic(v[13] == 638);
	14397	assert_or_panic(v[14] == 639);
	14398	assert_or_panic(v[15] == 640);
	14399	assert_or_panic(v[16] == 641);
	14400	assert_or_panic(v[17] == 642);
	14401	assert_or_panic(v[18] == 643);
	14402	assert_or_panic(v[19] == 644);
	14403	assert_or_panic(v[20] == 645);
	14404	assert_or_panic(v[21] == 646);
	14405	assert_or_panic(v[22] == 647);
	14406	assert_or_panic(v[23] == 648);
	14407	assert_or_panic(v[24] == 649);
	14408	assert_or_panic(v[25] == 650);
	14409	assert_or_panic(v[26] == 651);
	14410	assert_or_panic(v[27] == 652);
	14411	assert_or_panic(v[28] == 653);
	14412	assert_or_panic(v[29] == 654);
	14413	assert_or_panic(v[30] == 655);
	14414	assert_or_panic(v[31] == 656);
	14415	assert_or_panic(v[32] == 657);
	14416	assert_or_panic(v[33] == 658);
	14417	assert_or_panic(v[34] == 659);
	14418	assert_or_panic(v[35] == 660);
	14419	assert_or_panic(v[36] == 661);
	14420	assert_or_panic(v[37] == 662);
	14421	assert_or_panic(v[38] == 663);
	14422	assert_or_panic(v[39] == 664);
	14423	assert_or_panic(v[40] == 665);
	14424	assert_or_panic(v[41] == 666);
	14425	assert_or_panic(v[42] == 667);
	14426	assert_or_panic(v[43] == 668);
	14427	assert_or_panic(v[44] == 669);
	14428	assert_or_panic(v[45] == 670);
	14429	assert_or_panic(v[46] == 671);
	14430	assert_or_panic(v[47] == 672);
	14431	assert_or_panic(v[48] == 673);
	14432	assert_or_panic(v[49] == 674);
	14433	assert_or_panic(v[50] == 675);
	14434	assert_or_panic(v[51] == 676);
	14435	assert_or_panic(v[52] == 677);
	14436	assert_or_panic(v[53] == 678);
	14437	assert_or_panic(v[54] == 679);
	14438	assert_or_panic(v[55] == 680);
	14439	assert_or_panic(v[56] == 681);
	14440	assert_or_panic(v[57] == 682);
	14441	assert_or_panic(v[58] == 683);
	14442	assert_or_panic(v[59] == 684);
	14443	assert_or_panic(v[60] == 685);
	14444	assert_or_panic(v[61] == 686);
	14445	assert_or_panic(v[62] == 687);
	14446	assert_or_panic(v[63] == 688);
	14447	zig_vector_64_f64((Vector_64_f64){
	14448	689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704,
	14449	705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720,
	14450	721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736,
	14451	737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752,
	14452	}, 64);
	14453	}
	14454
	14455	struct Struct_u8 {
	14456	uint8_t a;
	14457	};
	14458
	14459	struct Struct_u8 zig_ret_struct_u8(void);
	14460	void zig_struct_u8(struct Struct_u8, size_t);
	14461
	14462	struct Struct_u8 c_ret_struct_u8(void) {
	14463	return (struct Struct_u8){ .a = 4 };
	14464	}
	14465	void c_struct_u8(struct Struct_u8 s, size_t i) {
	14466	assert_or_panic(s.a == 5);
	14467	assert_or_panic(i == 6);
	14468	}
	14469	void c_test_struct_u8(void) {
	14470	struct Struct_u8 s = zig_ret_struct_u8();
	14471	assert_or_panic(s.a == 1);
	14472	zig_struct_u8((struct Struct_u8){ .a = 2 }, 3);
	14473	}
	14474
	14475	struct Struct_u8_u8 {
	14476	uint8_t a, b;
	14477	};
	14478
	14479	struct Struct_u8_u8 zig_ret_struct_u8_u8(void);
	14480	void zig_struct_u8_u8(struct Struct_u8_u8, size_t);
	14481
	14482	struct Struct_u8_u8 c_ret_struct_u8_u8(void) {
	14483	return (struct Struct_u8_u8){ .a = 6, .b = 7 };
	14484	}
	14485	void c_struct_u8_u8(struct Struct_u8_u8 s, size_t i) {
	14486	assert_or_panic(s.a == 8);
	14487	assert_or_panic(s.b == 9);
	14488	assert_or_panic(i == 10);
	14489	}
	14490	void c_test_struct_u8_u8(void) {
	14491	struct Struct_u8_u8 s = zig_ret_struct_u8_u8();
	14492	assert_or_panic(s.a == 1);
	14493	assert_or_panic(s.b == 2);
	14494	zig_struct_u8_u8((struct Struct_u8_u8){ .a = 3, .b = 4 }, 5);
	14495	}
	14496
	14497	struct Struct_u8_u8_u8 {
	14498	uint8_t a, b, c;
	14499	};
	14500
	14501	struct Struct_u8_u8_u8 zig_ret_struct_u8_u8_u8(void);
	14502	void zig_struct_u8_u8_u8(struct Struct_u8_u8_u8, size_t);
	14503
	14504	struct Struct_u8_u8_u8 c_ret_struct_u8_u8_u8(void) {
	14505	return (struct Struct_u8_u8_u8){ .a = 8, .b = 9, .c = 10 };
	14506	}
	14507	void c_struct_u8_u8_u8(struct Struct_u8_u8_u8 s, size_t i) {
	14508	assert_or_panic(s.a == 11);
	14509	assert_or_panic(s.b == 12);
	14510	assert_or_panic(s.c == 13);
	14511	assert_or_panic(i == 14);
	14512	}
	14513	void c_test_struct_u8_u8_u8(void) {
	14514	struct Struct_u8_u8_u8 s = zig_ret_struct_u8_u8_u8();
	14515	assert_or_panic(s.a == 1);
	14516	assert_or_panic(s.b == 2);
	14517	assert_or_panic(s.c == 3);
	14518	zig_struct_u8_u8_u8((struct Struct_u8_u8_u8){ .a = 4, .b = 5, .c = 6 }, 7);
	14519	}
	14520
	14521	struct Struct_u8_u8_u8_u8 {
	14522	uint8_t a, b, c, d;
	14523	};
	14524
	14525	struct Struct_u8_u8_u8_u8 zig_ret_struct_u8_u8_u8_u8(void);
	14526	void zig_struct_u8_u8_u8_u8(struct Struct_u8_u8_u8_u8, size_t);
	14527
	14528	struct Struct_u8_u8_u8_u8 c_ret_struct_u8_u8_u8_u8(void) {
	14529	return (struct Struct_u8_u8_u8_u8){ .a = 10, .b = 11, .c = 12, .d = 13 };
	14530	}
	14531	void c_struct_u8_u8_u8_u8(struct Struct_u8_u8_u8_u8 s, size_t i) {
	14532	assert_or_panic(s.a == 14);
	14533	assert_or_panic(s.b == 15);
	14534	assert_or_panic(s.c == 16);
	14535	assert_or_panic(s.d == 17);
	14536	assert_or_panic(i == 18);
	14537	}
	14538	void c_test_struct_u8_u8_u8_u8(void) {
	14539	struct Struct_u8_u8_u8_u8 s = zig_ret_struct_u8_u8_u8_u8();
	14540	assert_or_panic(s.a == 1);
	14541	assert_or_panic(s.b == 2);
	14542	assert_or_panic(s.c == 3);
	14543	assert_or_panic(s.d == 4);
	14544	zig_struct_u8_u8_u8_u8((struct Struct_u8_u8_u8_u8){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9);
	14545	}
	14546
	14547	struct Struct_u16 {
	14548	uint16_t a;
	14549	};
	14550
	14551	struct Struct_u16 zig_ret_struct_u16(void);
	14552	void zig_struct_u16(struct Struct_u16, size_t);
	14553
	14554	struct Struct_u16 c_ret_struct_u16(void) {
	14555	return (struct Struct_u16){ .a = 4 };
	14556	}
	14557	void c_struct_u16(struct Struct_u16 s, size_t i) {
	14558	assert_or_panic(s.a == 5);
	14559	assert_or_panic(i == 6);
	14560	}
	14561	void c_test_struct_u16(void) {
	14562	struct Struct_u16 s = zig_ret_struct_u16();
	14563	assert_or_panic(s.a == 1);
	14564	zig_struct_u16((struct Struct_u16){ .a = 2 }, 3);
	14565	}
	14566
	14567	struct Struct_u16_u16 {
	14568	uint16_t a, b;
	14569	};
	14570
	14571	struct Struct_u16_u16 zig_ret_struct_u16_u16(void);
	14572	void zig_struct_u16_u16(struct Struct_u16_u16, size_t);
	14573
	14574	struct Struct_u16_u16 c_ret_struct_u16_u16(void) {
	14575	return (struct Struct_u16_u16){ .a = 6, .b = 7 };
	14576	}
	14577	void c_struct_u16_u16(struct Struct_u16_u16 s, size_t i) {
	14578	assert_or_panic(s.a == 8);
	14579	assert_or_panic(s.b == 9);
	14580	assert_or_panic(i == 10);
	14581	}
	14582	void c_test_struct_u16_u16(void) {
	14583	struct Struct_u16_u16 s = zig_ret_struct_u16_u16();
	14584	assert_or_panic(s.a == 1);
	14585	assert_or_panic(s.b == 2);
	14586	zig_struct_u16_u16((struct Struct_u16_u16){ .a = 3, .b = 4 }, 5);
	14587	}
	14588
	14589	struct Struct_u16_u16_u16 {
	14590	uint16_t a, b, c;
	14591	};
	14592
	14593	struct Struct_u16_u16_u16 zig_ret_struct_u16_u16_u16(void);
	14594	void zig_struct_u16_u16_u16(struct Struct_u16_u16_u16, size_t);
	14595
	14596	struct Struct_u16_u16_u16 c_ret_struct_u16_u16_u16(void) {
	14597	return (struct Struct_u16_u16_u16){ .a = 8, .b = 9, .c = 10 };
	14598	}
	14599	void c_struct_u16_u16_u16(struct Struct_u16_u16_u16 s, size_t i) {
	14600	assert_or_panic(s.a == 11);
	14601	assert_or_panic(s.b == 12);
	14602	assert_or_panic(s.c == 13);
	14603	assert_or_panic(i == 14);
	14604	}
	14605	void c_test_struct_u16_u16_u16(void) {
	14606	struct Struct_u16_u16_u16 s = zig_ret_struct_u16_u16_u16();
	14607	assert_or_panic(s.a == 1);
	14608	assert_or_panic(s.b == 2);
	14609	assert_or_panic(s.c == 3);
	14610	zig_struct_u16_u16_u16((struct Struct_u16_u16_u16){ .a = 4, .b = 5, .c = 6 }, 7);
	14611	}
	14612
	14613	struct Struct_u16_u16_u16_u16 {
	14614	uint16_t a, b, c, d;
	14615	};
	14616
	14617	struct Struct_u16_u16_u16_u16 zig_ret_struct_u16_u16_u16_u16(void);
	14618	void zig_struct_u16_u16_u16_u16(struct Struct_u16_u16_u16_u16, size_t);
	14619
	14620	struct Struct_u16_u16_u16_u16 c_ret_struct_u16_u16_u16_u16(void) {
	14621	return (struct Struct_u16_u16_u16_u16){ .a = 10, .b = 11, .c = 12, .d = 13 };
	14622	}
	14623	void c_struct_u16_u16_u16_u16(struct Struct_u16_u16_u16_u16 s, size_t i) {
	14624	assert_or_panic(s.a == 14);
	14625	assert_or_panic(s.b == 15);
	14626	assert_or_panic(s.c == 16);
	14627	assert_or_panic(s.d == 17);
	14628	assert_or_panic(i == 18);
	14629	}
	14630	void c_test_struct_u16_u16_u16_u16(void) {
	14631	struct Struct_u16_u16_u16_u16 s = zig_ret_struct_u16_u16_u16_u16();
	14632	assert_or_panic(s.a == 1);
	14633	assert_or_panic(s.b == 2);
	14634	assert_or_panic(s.c == 3);
	14635	assert_or_panic(s.d == 4);
	14636	zig_struct_u16_u16_u16_u16((struct Struct_u16_u16_u16_u16){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9);
	14637	}
	14638
	14639	struct Struct_u32 {
	14640	uint32_t a;
	14641	};
	14642
	14643	struct Struct_u32 zig_ret_struct_u32(void);
	14644	void zig_struct_u32(struct Struct_u32, size_t);
	14645
	14646	struct Struct_u32 c_ret_struct_u32(void) {
	14647	return (struct Struct_u32){ .a = 4 };
	14648	}
	14649	void c_struct_u32(struct Struct_u32 s, size_t i) {
	14650	assert_or_panic(s.a == 5);
	14651	assert_or_panic(i == 6);
	14652	}
	14653	void c_test_struct_u32(void) {
	14654	struct Struct_u32 s = zig_ret_struct_u32();
	14655	assert_or_panic(s.a == 1);
	14656	zig_struct_u32((struct Struct_u32){ .a = 2 }, 3);
	14657	}
	14658
	14659	struct Struct_u32_u32 {
	14660	uint32_t a, b;
	14661	};
	14662
	14663	struct Struct_u32_u32 zig_ret_struct_u32_u32(void);
	14664	void zig_struct_u32_u32(struct Struct_u32_u32, size_t);
	14665
	14666	struct Struct_u32_u32 c_ret_struct_u32_u32(void) {
	14667	return (struct Struct_u32_u32){ .a = 6, .b = 7 };
	14668	}
	14669	void c_struct_u32_u32(struct Struct_u32_u32 s, size_t i) {
	14670	assert_or_panic(s.a == 8);
	14671	assert_or_panic(s.b == 9);
	14672	assert_or_panic(i == 10);
	14673	}
	14674	void c_test_struct_u32_u32(void) {
	14675	struct Struct_u32_u32 s = zig_ret_struct_u32_u32();
	14676	assert_or_panic(s.a == 1);
	14677	assert_or_panic(s.b == 2);
	14678	zig_struct_u32_u32((struct Struct_u32_u32){ .a = 3, .b = 4 }, 5);
	14679	}
	14680
	14681	struct Struct_u32_u32_u32 {
	14682	uint32_t a, b, c;
	14683	};
	14684
	14685	struct Struct_u32_u32_u32 zig_ret_struct_u32_u32_u32(void);
	14686	void zig_struct_u32_u32_u32(struct Struct_u32_u32_u32, size_t);
	14687
	14688	struct Struct_u32_u32_u32 c_ret_struct_u32_u32_u32(void) {
	14689	return (struct Struct_u32_u32_u32){ .a = 8, .b = 9, .c = 10 };
	14690	}
	14691	void c_struct_u32_u32_u32(struct Struct_u32_u32_u32 s, size_t i) {
	14692	assert_or_panic(s.a == 11);
	14693	assert_or_panic(s.b == 12);
	14694	assert_or_panic(s.c == 13);
	14695	assert_or_panic(i == 14);
	14696	}
	14697	void c_test_struct_u32_u32_u32(void) {
	14698	struct Struct_u32_u32_u32 s = zig_ret_struct_u32_u32_u32();
	14699	assert_or_panic(s.a == 1);
	14700	assert_or_panic(s.b == 2);
	14701	assert_or_panic(s.c == 3);
	14702	zig_struct_u32_u32_u32((struct Struct_u32_u32_u32){ .a = 4, .b = 5, .c = 6 }, 7);
	14703	}
	14704
	14705	struct Struct_u32_u32_u32_u32 {
	14706	uint32_t a, b, c, d;
	14707	};
	14708
	14709	struct Struct_u32_u32_u32_u32 zig_ret_struct_u32_u32_u32_u32(void);
	14710	void zig_struct_u32_u32_u32_u32(struct Struct_u32_u32_u32_u32, size_t);
	14711
	14712	struct Struct_u32_u32_u32_u32 c_ret_struct_u32_u32_u32_u32(void) {
	14713	return (struct Struct_u32_u32_u32_u32){ .a = 10, .b = 11, .c = 12, .d = 13 };
	14714	}
	14715	void c_struct_u32_u32_u32_u32(struct Struct_u32_u32_u32_u32 s, size_t i) {
	14716	assert_or_panic(s.a == 14);
	14717	assert_or_panic(s.b == 15);
	14718	assert_or_panic(s.c == 16);
	14719	assert_or_panic(s.d == 17);
	14720	assert_or_panic(i == 18);
	14721	}
	14722	void c_test_struct_u32_u32_u32_u32(void) {
	14723	struct Struct_u32_u32_u32_u32 s = zig_ret_struct_u32_u32_u32_u32();
	14724	assert_or_panic(s.a == 1);
	14725	assert_or_panic(s.b == 2);
	14726	assert_or_panic(s.c == 3);
	14727	assert_or_panic(s.d == 4);
	14728	zig_struct_u32_u32_u32_u32((struct Struct_u32_u32_u32_u32){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9);
	14729	}
	14730
	14731	struct Struct_u64 {
	14732	uint64_t a;
	14733	};
	14734
	14735	struct Struct_u64 zig_ret_struct_u64(void);
	14736	void zig_struct_u64(struct Struct_u64, size_t);
	14737
	14738	struct Struct_u64 c_ret_struct_u64(void) {
	14739	return (struct Struct_u64){ .a = 4 };
	14740	}
	14741	void c_struct_u64(struct Struct_u64 s, size_t i) {
	14742	assert_or_panic(s.a == 5);
	14743	assert_or_panic(i == 6);
	14744	}
	14745	void c_test_struct_u64(void) {
	14746	struct Struct_u64 s = zig_ret_struct_u64();
	14747	assert_or_panic(s.a == 1);
	14748	zig_struct_u64((struct Struct_u64){ .a = 2 }, 3);
	14749	}
	14750
	14751	struct Struct_u64_u64 {
	14752	uint64_t a;
	14753	uint64_t b;
	14754	};
	14755
	14756	struct Struct_u64_u64 zig_ret_struct_u64_u64(void);
	14757	void zig_struct_u64_u64(struct Struct_u64_u64, size_t);
	14758	void zig_1_struct_u64_u64(size_t, struct Struct_u64_u64, size_t);
	14759	void zig_2_struct_u64_u64(size_t, size_t, struct Struct_u64_u64, size_t);
	14760	void zig_3_struct_u64_u64(size_t, size_t, size_t, struct Struct_u64_u64, size_t);
	14761	void zig_4_struct_u64_u64(size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
	14762	void zig_5_struct_u64_u64(size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
	14763	void zig_6_struct_u64_u64(size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
	14764	void zig_7_struct_u64_u64(size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
	14765	void zig_8_struct_u64_u64(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
	14766
	14767	struct Struct_u64_u64 c_ret_struct_u64_u64(void) {
	14768	return (struct Struct_u64_u64){ .a = 21, .b = 22 };
	14769	}
	14770	void c_struct_u64_u64(struct Struct_u64_u64 s, size_t i) {
	14771	assert_or_panic(s.a == 23);
	14772	assert_or_panic(s.b == 24);
	14773	assert_or_panic(i == 1);
	14774	}
	14775	void c_1_struct_u64_u64(size_t a0, struct Struct_u64_u64 s, size_t i) {
	14776	assert_or_panic(s.a == 25);
	14777	assert_or_panic(s.b == 26);
	14778	assert_or_panic(i == 2);
	14779	}
	14780	void c_2_struct_u64_u64(size_t a0, size_t a1, struct Struct_u64_u64 s, size_t i) {
	14781	assert_or_panic(s.a == 27);
	14782	assert_or_panic(s.b == 28);
	14783	assert_or_panic(i == 3);
	14784	}
	14785	void c_3_struct_u64_u64(size_t a0, size_t a1, size_t a2, struct Struct_u64_u64 s, size_t i) {
	14786	assert_or_panic(s.a == 29);
	14787	assert_or_panic(s.b == 30);
	14788	assert_or_panic(i == 4);
	14789	}
	14790	void c_4_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, struct Struct_u64_u64 s, size_t i) {
	14791	assert_or_panic(s.a == 31);
	14792	assert_or_panic(s.b == 32);
	14793	assert_or_panic(i == 5);
	14794	}
	14795	void c_5_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, struct Struct_u64_u64 s, size_t i) {
	14796	assert_or_panic(s.a == 33);
	14797	assert_or_panic(s.b == 34);
	14798	assert_or_panic(i == 6);
	14799	}
	14800	void c_6_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, struct Struct_u64_u64 s, size_t i) {
	14801	assert_or_panic(s.a == 35);
	14802	assert_or_panic(s.b == 36);
	14803	assert_or_panic(i == 7);
	14804	}
	14805	void c_7_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, struct Struct_u64_u64 s, size_t i) {
	14806	assert_or_panic(s.a == 37);
	14807	assert_or_panic(s.b == 38);
	14808	assert_or_panic(i == 8);
	14809	}
	14810	void c_8_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, size_t a7, struct Struct_u64_u64 s, size_t i) {
	14811	assert_or_panic(s.a == 39);
	14812	assert_or_panic(s.b == 40);
	14813	assert_or_panic(i == 9);
	14814	}
	14815	void c_test_struct_u64_u64(void) {
	14816	struct Struct_u64_u64 s = zig_ret_struct_u64_u64();
	14817	assert_or_panic(s.a == 1);
	14818	assert_or_panic(s.b == 2);
	14819	zig_struct_u64_u64((struct Struct_u64_u64){ .a = 3, .b = 4 }, 1);
	14820	zig_1_struct_u64_u64(0, (struct Struct_u64_u64){ .a = 5, .b = 6 }, 2);
	14821	zig_2_struct_u64_u64(0, 1, (struct Struct_u64_u64){ .a = 7, .b = 8 }, 3);
	14822	zig_3_struct_u64_u64(0, 1, 2, (struct Struct_u64_u64){ .a = 9, .b = 10 }, 4);
	14823	zig_4_struct_u64_u64(0, 1, 2, 3, (struct Struct_u64_u64){ .a = 11, .b = 12 }, 5);
	14824	zig_5_struct_u64_u64(0, 1, 2, 3, 4, (struct Struct_u64_u64){ .a = 13, .b = 14 }, 6);
	14825	zig_6_struct_u64_u64(0, 1, 2, 3, 4, 5, (struct Struct_u64_u64){ .a = 15, .b = 16 }, 7);
	14826	zig_7_struct_u64_u64(0, 1, 2, 3, 4, 5, 6, (struct Struct_u64_u64){ .a = 17, .b = 18 }, 8);
	14827	zig_8_struct_u64_u64(0, 1, 2, 3, 4, 5, 6, 7, (struct Struct_u64_u64){ .a = 19, .b = 20 }, 9);
	14828	}
	14829
	14830	struct Struct_u64_u64_u64 {
	14831	uint64_t a, b, c;
	14832	};
	14833
	14834	struct Struct_u64_u64_u64 zig_ret_struct_u64_u64_u64(void);
	14835	void zig_struct_u64_u64_u64(struct Struct_u64_u64_u64, size_t);
	14836
	14837	struct Struct_u64_u64_u64 c_ret_struct_u64_u64_u64(void) {
	14838	return (struct Struct_u64_u64_u64){ .a = 8, .b = 9, .c = 10 };
	14839	}
	14840	void c_struct_u64_u64_u64(struct Struct_u64_u64_u64 s, size_t i) {
	14841	assert_or_panic(s.a == 11);
	14842	assert_or_panic(s.b == 12);
	14843	assert_or_panic(s.c == 13);
	14844	assert_or_panic(i == 14);
	14845	}
	14846	void c_test_struct_u64_u64_u64(void) {
	14847	struct Struct_u64_u64_u64 s = zig_ret_struct_u64_u64_u64();
	14848	assert_or_panic(s.a == 1);
	14849	assert_or_panic(s.b == 2);
	14850	assert_or_panic(s.c == 3);
	14851	zig_struct_u64_u64_u64((struct Struct_u64_u64_u64){ .a = 4, .b = 5, .c = 6 }, 7);
	14852	}
	14853
	14854	struct Struct_u64_u64_u64_u64 {
	14855	uint64_t a, b, c, d;
	14856	};
	14857
	14858	struct Struct_u64_u64_u64_u64 zig_ret_struct_u64_u64_u64_u64(void);
	14859	void zig_struct_u64_u64_u64_u64(struct Struct_u64_u64_u64_u64, size_t);
	14860
	14861	struct Struct_u64_u64_u64_u64 c_ret_struct_u64_u64_u64_u64(void) {
	14862	return (struct Struct_u64_u64_u64_u64){ .a = 10, .b = 11, .c = 12, .d = 13 };
	14863	}
	14864	void c_struct_u64_u64_u64_u64(struct Struct_u64_u64_u64_u64 s, size_t i) {
	14865	assert_or_panic(s.a == 14);
	14866	assert_or_panic(s.b == 15);
	14867	assert_or_panic(s.c == 16);
	14868	assert_or_panic(s.d == 17);
	14869	assert_or_panic(i == 18);
	14870	}
	14871	void c_test_struct_u64_u64_u64_u64(void) {
	14872	struct Struct_u64_u64_u64_u64 s = zig_ret_struct_u64_u64_u64_u64();
	14873	assert_or_panic(s.a == 1);
	14874	assert_or_panic(s.b == 2);
	14875	assert_or_panic(s.c == 3);
	14876	assert_or_panic(s.d == 4);
	14877	zig_struct_u64_u64_u64_u64((struct Struct_u64_u64_u64_u64){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9);
	14878	}
	14879
	14880	struct Struct_f32 {
	14881	float a;
	14882	};
	14883
	14884	struct Struct_f32 zig_ret_struct_f32(void);
	14885	void zig_struct_f32(struct Struct_f32, size_t);
	14886
	14887	struct Struct_f32 c_ret_struct_f32(void) {
	14888	return (struct Struct_f32){ .a = 4 };
	14889	}
	14890	void c_struct_f32(struct Struct_f32 s, size_t i) {
	14891	assert_or_panic(s.a == 5);
	14892	assert_or_panic(i == 6);
	14893	}
	14894	void c_test_struct_f32(void) {
	14895	struct Struct_f32 s = zig_ret_struct_f32();
	14896	assert_or_panic(s.a == 1);
	14897	zig_struct_f32((struct Struct_f32){ .a = 2 }, 3);
	14898	}
	14899
	14900	struct Struct_f32_f32 {
	14901	float a, b;
	14902	};
	14903
	14904	struct Struct_f32_f32 zig_ret_struct_f32_f32(void);
	14905	void zig_struct_f32_f32(struct Struct_f32_f32, size_t);
	14906
	14907	struct Struct_f32_f32 c_ret_struct_f32_f32(void) {
	14908	return (struct Struct_f32_f32){ .a = 6, .b = 7 };
	14909	}
	14910	void c_struct_f32_f32(struct Struct_f32_f32 s, size_t i) {
	14911	assert_or_panic(s.a == 8);
	14912	assert_or_panic(s.b == 9);
	14913	assert_or_panic(i == 10);
	14914	}
	14915	void c_test_struct_f32_f32(void) {
	14916	struct Struct_f32_f32 s = zig_ret_struct_f32_f32();
	14917	assert_or_panic(s.a == 1);
	14918	assert_or_panic(s.b == 2);
	14919	zig_struct_f32_f32((struct Struct_f32_f32){ .a = 3, .b = 4 }, 5);
	14920	}
	14921
	14922	struct Struct_f32_f32_f32 {
	14923	float a, b, c;
	14924	};
	14925
	14926	struct Struct_f32_f32_f32 zig_ret_struct_f32_f32_f32(void);
	14927	void zig_struct_f32_f32_f32(struct Struct_f32_f32_f32, size_t);
	14928
	14929	struct Struct_f32_f32_f32 c_ret_struct_f32_f32_f32(void) {
	14930	return (struct Struct_f32_f32_f32){ .a = 8, .b = 9, .c = 10 };
	14931	}
	14932	void c_struct_f32_f32_f32(struct Struct_f32_f32_f32 s, size_t i) {
	14933	assert_or_panic(s.a == 11);
	14934	assert_or_panic(s.b == 12);
	14935	assert_or_panic(s.c == 13);
	14936	assert_or_panic(i == 14);
	14937	}
	14938	void c_test_struct_f32_f32_f32(void) {
	14939	struct Struct_f32_f32_f32 s = zig_ret_struct_f32_f32_f32();
	14940	assert_or_panic(s.a == 1);
	14941	assert_or_panic(s.b == 2);
	14942	assert_or_panic(s.c == 3);
	14943	zig_struct_f32_f32_f32((struct Struct_f32_f32_f32){ .a = 4, .b = 5, .c = 6 }, 7);
	14944	}
	14945
	14946	struct Struct_f32_f32_f32_f32 {
	14947	float a, b, c, d;
	14948	};
	14949
	14950	struct Struct_f32_f32_f32_f32 zig_ret_struct_f32_f32_f32_f32(void);
	14951	void zig_struct_f32_f32_f32_f32(struct Struct_f32_f32_f32_f32, size_t);
	14952
	14953	struct Struct_f32_f32_f32_f32 c_ret_struct_f32_f32_f32_f32(void) {
	14954	return (struct Struct_f32_f32_f32_f32){ .a = 10, .b = 11, .c = 12, .d = 13 };
	14955	}
	14956	void c_struct_f32_f32_f32_f32(struct Struct_f32_f32_f32_f32 s, size_t i) {
	14957	assert_or_panic(s.a == 14);
	14958	assert_or_panic(s.b == 15);
	14959	assert_or_panic(s.c == 16);
	14960	assert_or_panic(s.d == 17);
	14961	assert_or_panic(i == 18);
	14962	}
	14963	void c_test_struct_f32_f32_f32_f32(void) {
	14964	struct Struct_f32_f32_f32_f32 s = zig_ret_struct_f32_f32_f32_f32();
	14965	assert_or_panic(s.a == 1);
	14966	assert_or_panic(s.b == 2);
	14967	assert_or_panic(s.c == 3);
	14968	assert_or_panic(s.d == 4);
	14969	zig_struct_f32_f32_f32_f32((struct Struct_f32_f32_f32_f32){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9);
	14970	}
	14971
	14972	struct Struct_f32_f32_f32_f32_f32 {
	14973	float a, b, c, d, e;
	14974	};
	14975
	14976	struct Struct_f32_f32_f32_f32_f32 zig_ret_struct_f32_f32_f32_f32_f32(void);
	14977	void zig_struct_f32_f32_f32_f32_f32(struct Struct_f32_f32_f32_f32_f32, size_t);
	14978
	14979	struct Struct_f32_f32_f32_f32_f32 c_ret_struct_f32_f32_f32_f32_f32(void) {
	14980	return (struct Struct_f32_f32_f32_f32_f32){ .a = 12, .b = 13, .c = 14, .d = 15, .e = 16 };
	14981	}
	14982	void c_struct_f32_f32_f32_f32_f32(struct Struct_f32_f32_f32_f32_f32 s, size_t i) {
	14983	assert_or_panic(s.a == 17);
	14984	assert_or_panic(s.b == 18);
	14985	assert_or_panic(s.c == 19);
	14986	assert_or_panic(s.d == 20);
	14987	assert_or_panic(s.e == 21);
	14988	assert_or_panic(i == 22);
	14989	}
	14990	void c_test_struct_f32_f32_f32_f32_f32(void) {
	14991	struct Struct_f32_f32_f32_f32_f32 s = zig_ret_struct_f32_f32_f32_f32_f32();
	14992	assert_or_panic(s.a == 1);
	14993	assert_or_panic(s.b == 2);
	14994	assert_or_panic(s.c == 3);
	14995	assert_or_panic(s.d == 4);
	14996	assert_or_panic(s.e == 5);
	14997	zig_struct_f32_f32_f32_f32_f32((struct Struct_f32_f32_f32_f32_f32){ .a = 6, .b = 7, .c = 8, .d = 9, .e = 10 }, 11);
	14998	}
	14999
	15000	struct Struct_f32a8 {
	15001	alignas(8) float a;
	15002	};
	15003
	15004	struct Struct_f32a8 zig_ret_struct_f32a8(void);
	15005	void zig_struct_f32a8(struct Struct_f32a8, float);
	15006
	15007	struct Struct_f32a8 c_ret_struct_f32a8(void) {
	15008	return (struct Struct_f32a8){ .a = 4.125f };
	15009	}
	15010	void c_struct_f32a8(struct Struct_f32a8 s, float f) {
	15011	assert_or_panic(s.a == 5.375f);
	15012	assert_or_panic(f == 6.5f);
	15013	}
	15014	void c_test_struct_f32a8(void) {
	15015	struct Struct_f32a8 s = zig_ret_struct_f32a8();
	15016	assert_or_panic(s.a == 1.25f);
	15017	zig_struct_f32a8((struct Struct_f32a8){ .a = 2.75f }, 3.5f);
	15018	}
	15019
	15020	struct Struct_f32a8_f32a8 {
	15021	alignas(8) float a;
	15022	alignas(8) float b;
	15023	};
	15024
	15025	struct Struct_f32a8_f32a8 zig_ret_struct_f32a8_f32a8(void);
	15026	void zig_struct_f32a8_f32a8(struct Struct_f32a8_f32a8, float);
	15027
	15028	struct Struct_f32a8_f32a8 c_ret_struct_f32a8_f32a8(void) {
	15029	return (struct Struct_f32a8_f32a8){ .a = 6.625f, .b = 7.875f };
	15030	}
	15031	void c_struct_f32a8_f32a8(struct Struct_f32a8_f32a8 s, float f) {
	15032	assert_or_panic(s.a == 8.0625f);
	15033	assert_or_panic(s.b == 9.1875f);
	15034	assert_or_panic(f == 10.5f);
	15035	}
	15036	void c_test_struct_f32a8_f32a8(void) {
	15037	struct Struct_f32a8_f32a8 s = zig_ret_struct_f32a8_f32a8();
	15038	assert_or_panic(s.a == 1.25f);
	15039	assert_or_panic(s.b == 2.75f);
	15040	zig_struct_f32a8_f32a8((struct Struct_f32a8_f32a8){ .a = 3.125f, .b = 4.375f }, 5.5f);
	15041	}
	15042
	15043	struct Struct_f32f32_f32 {
	15044	struct {
	15045	float b, c;
	15046	} a;
	15047	float d;
	15048	};
	15049
	15050	struct Struct_f32f32_f32 zig_ret_struct_f32f32_f32(void);
	15051	void zig_struct_f32f32_f32(struct Struct_f32f32_f32);
	15052
	15053	struct Struct_f32f32_f32 c_ret_struct_f32f32_f32(void) {
	15054	return (struct Struct_f32f32_f32){ .a = { .b = 1.0f, .c = 2.0f }, .d = 3.0f };
	15055	}
	15056	void c_struct_f32f32_f32(struct Struct_f32f32_f32 s) {
	15057	assert_or_panic(s.a.b == 1.0f);
	15058	assert_or_panic(s.a.c == 2.0f);
	15059	assert_or_panic(s.d == 3.0f);
	15060	}
	15061	void c_test_struct_f32f32_f32(void) {
	15062	struct Struct_f32f32_f32 s = zig_ret_struct_f32f32_f32();
	15063	assert_or_panic(s.a.b == 1.0f);
	15064	assert_or_panic(s.a.c == 2.0f);
	15065	assert_or_panic(s.d == 3.0f);
	15066	zig_struct_f32f32_f32((struct Struct_f32f32_f32){ .a = { .b = 1.0f, .c = 2.0f }, .d = 3.0f });
	15067	}
	15068
	15069	struct Struct_f32_f32f32 {
	15070	float a;
	15071	struct {
	15072	float c, d;
	15073	} b;
	15074	};
	15075
	15076	struct Struct_f32_f32f32 zig_ret_struct_f32_f32f32(void);
	15077	void zig_struct_f32_f32f32(struct Struct_f32_f32f32);
	15078
	15079	struct Struct_f32_f32f32 c_ret_struct_f32_f32f32(void) {
	15080	return (struct Struct_f32_f32f32){ .a = 1.0f, .b = { .c = 2.0f, .d = 3.0f } };
	15081	}
	15082	void c_struct_f32_f32f32(struct Struct_f32_f32f32 s) {
	15083	assert_or_panic(s.a == 1.0f);
	15084	assert_or_panic(s.b.c == 2.0f);
	15085	assert_or_panic(s.b.d == 3.0f);
	15086	}
	15087	void c_test_struct_f32_f32f32(void) {
	15088	struct Struct_f32_f32f32 s = zig_ret_struct_f32_f32f32();
	15089	assert_or_panic(s.a == 1.0f);
	15090	assert_or_panic(s.b.c == 2.0f);
	15091	assert_or_panic(s.b.d == 3.0f);
	15092	zig_struct_f32_f32f32((struct Struct_f32_f32f32){ .a = 1.0f, .b = { .c = 2.0f, .d = 3.0f } });
	15093	}
	15094
	15095	struct Struct_f64 {
	15096	double a;
	15097	};
	15098
	15099	struct Struct_f64 zig_ret_struct_f64(void);
	15100	void zig_struct_f64(struct Struct_f64, size_t);
	15101
	15102	struct Struct_f64 c_ret_struct_f64(void) {
	15103	return (struct Struct_f64){ .a = 4 };
	15104	}
	15105	void c_struct_f64(struct Struct_f64 s, size_t i) {
	15106	assert_or_panic(s.a == 5);
	15107	assert_or_panic(i == 6);
	15108	}
	15109	void c_test_struct_f64(void) {
	15110	struct Struct_f64 s = zig_ret_struct_f64();
	15111	assert_or_panic(s.a == 1);
	15112	zig_struct_f64((struct Struct_f64){ .a = 2 }, 3);
	15113	}
	15114
	15115	struct Struct_f64_f64 {
	15116	double a, b;
	15117	};
	15118
	15119	struct Struct_f64_f64 zig_ret_struct_f64_f64(void);
	15120	void zig_struct_f64_f64(struct Struct_f64_f64, size_t);
	15121
	15122	struct Struct_f64_f64 c_ret_struct_f64_f64(void) {
	15123	return (struct Struct_f64_f64){ .a = 6, .b = 7 };
	15124	}
	15125	void c_struct_f64_f64(struct Struct_f64_f64 s, size_t i) {
	15126	assert_or_panic(s.a == 8);
	15127	assert_or_panic(s.b == 9);
	15128	assert_or_panic(i == 10);
	15129	}
	15130	void c_test_struct_f64_f64(void) {
	15131	struct Struct_f64_f64 s = zig_ret_struct_f64_f64();
	15132	assert_or_panic(s.a == 1);
	15133	assert_or_panic(s.b == 2);
	15134	zig_struct_f64_f64((struct Struct_f64_f64){ .a = 3, .b = 4 }, 5);
	15135	}
	15136
	15137	struct Struct_f64_f64_f64 {
	15138	double a, b, c;
	15139	};
	15140
	15141	struct Struct_f64_f64_f64 zig_ret_struct_f64_f64_f64(void);
	15142	void zig_struct_f64_f64_f64(struct Struct_f64_f64_f64, size_t);
	15143
	15144	struct Struct_f64_f64_f64 c_ret_struct_f64_f64_f64(void) {
	15145	return (struct Struct_f64_f64_f64){ .a = 8, .b = 9, .c = 10 };
	15146	}
	15147	void c_struct_f64_f64_f64(struct Struct_f64_f64_f64 s, size_t i) {
	15148	assert_or_panic(s.a == 11);
	15149	assert_or_panic(s.b == 12);
	15150	assert_or_panic(s.c == 13);
	15151	assert_or_panic(i == 14);
	15152	}
	15153	void c_test_struct_f64_f64_f64(void) {
	15154	struct Struct_f64_f64_f64 s = zig_ret_struct_f64_f64_f64();
	15155	assert_or_panic(s.a == 1);
	15156	assert_or_panic(s.b == 2);
	15157	assert_or_panic(s.c == 3);
	15158	zig_struct_f64_f64_f64((struct Struct_f64_f64_f64){ .a = 4, .b = 5, .c = 6 }, 7);
	15159	}
	15160
	15161	struct Struct_f64_f64_f64_f64 {
	15162	double a, b, c, d;
	15163	};
	15164
	15165	struct Struct_f64_f64_f64_f64 zig_ret_struct_f64_f64_f64_f64(void);
	15166	void zig_struct_f64_f64_f64_f64(struct Struct_f64_f64_f64_f64, size_t);
	15167
	15168	struct Struct_f64_f64_f64_f64 c_ret_struct_f64_f64_f64_f64(void) {
	15169	return (struct Struct_f64_f64_f64_f64){ .a = 10, .b = 11, .c = 12, .d = 13 };
	15170	}
	15171	void c_struct_f64_f64_f64_f64(struct Struct_f64_f64_f64_f64 s, size_t i) {
	15172	assert_or_panic(s.a == 14);
	15173	assert_or_panic(s.b == 15);
	15174	assert_or_panic(s.c == 16);
	15175	assert_or_panic(s.d == 17);
	15176	assert_or_panic(i == 18);
	15177	}
	15178	void c_test_struct_f64_f64_f64_f64(void) {
	15179	struct Struct_f64_f64_f64_f64 s = zig_ret_struct_f64_f64_f64_f64();
	15180	assert_or_panic(s.a == 1);
	15181	assert_or_panic(s.b == 2);
	15182	assert_or_panic(s.c == 3);
	15183	assert_or_panic(s.d == 4);
	15184	zig_struct_f64_f64_f64_f64((struct Struct_f64_f64_f64_f64){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9);
	15185	}
	15186
	15187	struct Struct_f64_f64_f64_f64_f64 {
	15188	double a, b, c, d, e;
	15189	};
	15190
	15191	struct Struct_f64_f64_f64_f64_f64 zig_ret_struct_f64_f64_f64_f64_f64(void);
	15192	void zig_struct_f64_f64_f64_f64_f64(struct Struct_f64_f64_f64_f64_f64, size_t);
	15193
	15194	struct Struct_f64_f64_f64_f64_f64 c_ret_struct_f64_f64_f64_f64_f64(void) {
	15195	return (struct Struct_f64_f64_f64_f64_f64){ .a = 12, .b = 13, .c = 14, .d = 15, .e = 16 };
	15196	}
	15197	void c_struct_f64_f64_f64_f64_f64(struct Struct_f64_f64_f64_f64_f64 s, size_t i) {
	15198	assert_or_panic(s.a == 17);
	15199	assert_or_panic(s.b == 18);
	15200	assert_or_panic(s.c == 19);
	15201	assert_or_panic(s.d == 20);
	15202	assert_or_panic(s.e == 21);
	15203	assert_or_panic(i == 22);
	15204	}
	15205	void c_test_struct_f64_f64_f64_f64_f64(void) {
	15206	struct Struct_f64_f64_f64_f64_f64 s = zig_ret_struct_f64_f64_f64_f64_f64();
	15207	assert_or_panic(s.a == 1);
	15208	assert_or_panic(s.b == 2);
	15209	assert_or_panic(s.c == 3);
	15210	assert_or_panic(s.d == 4);
	15211	assert_or_panic(s.e == 5);
	15212	zig_struct_f64_f64_f64_f64_f64((struct Struct_f64_f64_f64_f64_f64){ .a = 6, .b = 7, .c = 8, .d = 9, .e = 10 }, 11);
	15213	}
	15214
	15215	struct Struct_u32_Union_u32_u32u32 {
	15216	uint32_t a;
	15217	union {
	15218	struct {
	15219	uint32_t d, e;
	15220	} c;
	15221	} b;
	15222	};
	15223
	15224	struct Struct_u32_Union_u32_u32u32 zig_ret_struct_u32_union_u32_u32u32(void);
	15225	void zig_struct_u32_union_u32_u32u32(struct Struct_u32_Union_u32_u32u32);
	15226
	15227	struct Struct_u32_Union_u32_u32u32 c_ret_struct_u32_union_u32_u32u32(void) {
	15228	struct Struct_u32_Union_u32_u32u32 s;
	15229	s.a = 1;
	15230	s.b.c.d = 2;
	15231	s.b.c.e = 3;
	15232	return s;
	15233	}
	15234	void c_struct_u32_union_u32_u32u32(struct Struct_u32_Union_u32_u32u32 s) {
	15235	assert_or_panic(s.a == 1);
	15236	assert_or_panic(s.b.c.d == 2);
	15237	assert_or_panic(s.b.c.e == 3);
	15238	}
	15239	void c_test_struct_u32_union_u32_u32u32(void) {
	15240	struct Struct_u32_Union_u32_u32u32 s = zig_ret_struct_u32_union_u32_u32u32();
	15241	assert_or_panic(s.a == 1);
	15242	assert_or_panic(s.b.c.d == 2);
	15243	assert_or_panic(s.b.c.e == 3);
	15244	zig_struct_u32_union_u32_u32u32(s);
	15245	}
	15246
	15247	struct Struct_i32_i32 {
	15248	int32_t a;
	15249	int32_t b;
	15250	};
	15251
	15252	void zig_struct_i32_i32(struct Struct_i32_i32);
	15253
	15254	struct BigStruct {
	15255	uint64_t a;
	15256	uint64_t b;
	15257	uint64_t c;
	15258	uint64_t d;
	15259	uint8_t e;
	15260	};
	15261
	15262	void zig_big_struct(struct BigStruct);
	15263
	15264	union BigUnion {
	15265	struct BigStruct a;
	15266	};
	15267
	15268	void zig_big_union(union BigUnion);
	15269
	15270	struct MedStructMixed {
	15271	uint32_t a;
	15272	float b;
	15273	float c;
	15274	uint32_t d;
	15275	};
2722	15276
2723		void zig_vector_2_bool(Vector2Bool vec);
2724		void zig_vector_4_bool(Vector4Bool vec);
2725		void zig_vector_8_bool(Vector8Bool vec);
2726		void zig_vector_16_bool(Vector16Bool vec);
2727		void zig_vector_32_bool(Vector32Bool vec);
2728		void zig_vector_64_bool(Vector64Bool vec);
2729		void zig_vector_128_bool(Vector128Bool vec);
2730		void zig_vector_256_bool(Vector256Bool vec);
2731		void zig_vector_512_bool(Vector512Bool vec);
2732
2733		Vector2Bool zig_ret_vector_2_bool(void);
2734		Vector4Bool zig_ret_vector_4_bool(void);
2735		Vector8Bool zig_ret_vector_8_bool(void);
2736		Vector16Bool zig_ret_vector_16_bool(void);
2737		Vector32Bool zig_ret_vector_32_bool(void);
2738		Vector64Bool zig_ret_vector_64_bool(void);
2739		Vector128Bool zig_ret_vector_128_bool(void);
2740		Vector256Bool zig_ret_vector_256_bool(void);
2741		Vector512Bool zig_ret_vector_512_bool(void);
	15277	void zig_med_struct_mixed(struct MedStructMixed);
	15278	struct MedStructMixed zig_ret_med_struct_mixed();
2742	15279
	15280	void zig_small_packed_struct(uint8_t);
	15281	#ifndef ZIG_NO_I128
	15282	void zig_big_packed_struct(__int128);
2743	15283	#endif
2744	15284
2745		typedef struct Vector3 {
2746		float x;
2747		float y;
2748		float z;
2749		} Vector3;
2750
2751		typedef struct Vector5 {
2752		float x;
2753		float y;
2754		float z;
2755		float w;
2756		float q;
2757		} Vector5;
2758
2759		typedef struct Rect {
2760		uint32_t left;
2761		uint32_t right;
2762		uint32_t top;
2763		uint32_t bottom;
2764		} Rect;
2765
2766		void zig_multiple_struct_ints(struct Rect, struct Rect);
2767
2768		typedef struct FloatRect {
2769		float left;
2770		float right;
2771		float top;
2772		float bottom;
2773		} FloatRect;
2774
2775		void zig_multiple_struct_floats(struct FloatRect, struct FloatRect);
	15285	struct SplitStructInts {
	15286	uint64_t a;
	15287	uint8_t b;
	15288	uint32_t c;
	15289	};
	15290	void zig_split_struct_ints(struct SplitStructInts);
	15291
	15292	struct SplitStructMixed {
	15293	uint64_t a;
	15294	uint8_t b;
	15295	float c;
	15296	};
	15297	void zig_split_struct_mixed(struct SplitStructMixed);
	15298	struct SplitStructMixed zig_ret_split_struct_mixed();
	15299
	15300	struct BigStruct zig_big_struct_both(struct BigStruct);
2776	15301
2777	15302	void run_c_tests(void) {
2778	15303	zig_u8(0xff);
...	...	@@ -2849,202 +15374,34 @@ void run_c_tests(void) {
2849	15374	}
2850	15375	#endif
2851	15376
2852		#if !defined(__mips64)
2853		#if !defined(ZIG_PPC32)
2854		#if !defined(__s390x__)
2855		#if !(defined(_WIN32) && defined(__i386__))
2856		{
2857		struct Struct_u8 s = zig_ret_struct_u8();
2858		assert_or_panic(s.a == 1);
2859		zig_struct_u8((struct Struct_u8){ .a = 2 }, 3);
2860		}
2861		#endif
2862		#endif
2863		#endif
2864		#endif
2865
2866		#if !defined(__mips64)
2867		#if !defined(ZIG_PPC32)
2868		#if !defined(__s390x__)
2869		#if !(defined(_WIN32) && defined(__i386__))
2870		{
2871		struct Struct_u16 s = zig_ret_struct_u16();
2872		assert_or_panic(s.a == 7);
2873		zig_struct_u16((struct Struct_u16){ .a = 8 }, 9);
2874		}
2875		#endif
2876		#endif
2877		#endif
2878		#endif
2879
2880		#if !defined(__mips64)
2881		#if !defined(ZIG_PPC32)
2882		#if !defined(__s390x__)
2883		#if !(defined(_WIN32) && defined(__i386__))
2884		{
2885		struct Struct_u32 s = zig_ret_struct_u32();
2886		assert_or_panic(s.a == 13);
2887		zig_struct_u32((struct Struct_u32){ .a = 14 }, 15);
2888		}
2889		#endif
2890		#endif
2891		#endif
2892		#endif
2893
2894		#if !defined(ZIG_PPC32)
2895		#if !defined(ZIG_RISCV32)
2896		#if !defined(__s390x__)
2897		#if !(defined(_WIN32) && defined(__i386__))
2898		{
2899		struct Struct_u64 s = zig_ret_struct_u64();
2900		assert_or_panic(s.a == 19);
2901		zig_struct_u64((struct Struct_u64){ .a = 20 }, 21);
2902		}
2903		#endif
2904		#endif
2905		#endif
2906		#endif
2907
2908		#if !defined(ZIG_PPC32) && !defined(__hexagon__) && !defined(__s390x__)
2909		{
2910		struct Struct_u64_u64 s = zig_ret_struct_u64_u64();
2911		assert_or_panic(s.a == 1);
2912		assert_or_panic(s.b == 2);
2913		zig_struct_u64_u64_0((struct Struct_u64_u64){ .a = 3, .b = 4 }, 1);
2914		zig_struct_u64_u64_1(0, (struct Struct_u64_u64){ .a = 5, .b = 6 }, 2);
2915		zig_struct_u64_u64_2(0, 1, (struct Struct_u64_u64){ .a = 7, .b = 8 }, 3);
2916		zig_struct_u64_u64_3(0, 1, 2, (struct Struct_u64_u64){ .a = 9, .b = 10 }, 4);
2917		zig_struct_u64_u64_4(0, 1, 2, 3, (struct Struct_u64_u64){ .a = 11, .b = 12 }, 5);
2918		zig_struct_u64_u64_5(0, 1, 2, 3, 4, (struct Struct_u64_u64){ .a = 13, .b = 14 }, 6);
2919		zig_struct_u64_u64_6(0, 1, 2, 3, 4, 5, (struct Struct_u64_u64){ .a = 15, .b = 16 }, 7);
2920		zig_struct_u64_u64_7(0, 1, 2, 3, 4, 5, 6, (struct Struct_u64_u64){ .a = 17, .b = 18 }, 8);
2921		zig_struct_u64_u64_8(0, 1, 2, 3, 4, 5, 6, 7, (struct Struct_u64_u64){ .a = 19, .b = 20 }, 9);
2922		}
2923
2924		#if !defined(__mips64__)
2925		#if !(defined(_WIN32) && defined(__i386__))
2926		{
2927		struct Struct_f32 s = zig_ret_struct_f32();
2928		assert_or_panic(s.a == 2.5f);
2929		zig_struct_f32((struct Struct_f32){ .a = 2.5f });
2930		}
2931		#endif
2932		#endif
2933
2934		#if !(defined(__arm__) && defined(__SOFTFP__))
2935		#if !defined(ZIG_RISCV32)
2936		#if !(defined(_WIN32) && defined(__i386__))
2937		{
2938		struct Struct_f64 s = zig_ret_struct_f64();
2939		assert_or_panic(s.a == 2.5);
2940		zig_struct_f64((struct Struct_f64){ .a = 2.5 });
2941		}
2942		#endif
2943		#endif
2944		#endif
2945
2946		#if !defined(__arm__)
2947		#if !defined(__loongarch__)
2948		#if !defined(__mips64__)
2949		#if !defined(__powerpc__)
2950		#if !defined(ZIG_RISCV32)
2951		#if !defined(__s390x__)
2952		#if !defined(__i386__)
2953		{
2954		struct Struct_f32a8 s = zig_ret_struct_f32a8();
2955		assert_or_panic(s.a == 1.25f);
2956		zig_struct_f32a8((struct Struct_f32a8){ .a = 2.75f }, 3.5f);
2957		}
2958		#endif
2959		#endif
2960		#endif
2961		#endif
2962		#endif
2963		#endif
2964		#endif
2965
2966		#if !defined(__arm__)
2967		#if !defined(__loongarch__)
2968		#if !defined(__mips64__)
2969		#if !defined(__powerpc__)
2970		#if !defined(__riscv)
2971		#if !defined(__s390x__)
2972		#if !defined(__i386__)
	15377	#if !(defined(__i386__) && defined(_WIN32))
	15378	#ifndef __loongarch__
	15379	#ifndef ZIG_MIPS64
	15380	#ifndef __powerpc__
	15381	#ifndef __s390x__
2973	15382	{
2974		struct Struct_f32a8_f32a8 s = zig_ret_struct_f32a8_f32a8();
2975		assert_or_panic(s.a == 1.25f);
2976		assert_or_panic(s.b == 2.75f);
2977		zig_struct_f32a8_f32a8((struct Struct_f32a8_f32a8){ .a = 3.125f, .b = 4.375f }, 5.5f);
	15383	struct Struct_i32_i32 s = {1, 2};
	15384	zig_struct_i32_i32(s);
2978	15385	}
2979	15386	#endif
2980	15387	#endif
2981	15388	#endif
2982	15389	#endif
2983	15390	#endif
2984		#endif
2985		#endif
2986
2987		#if !(defined(__arm__) && defined(__SOFTFP__))
2988		#if !defined(__loongarch__) && !defined(__mips64__)
2989		{
2990		struct Struct_f32f32_f32 s = zig_ret_struct_f32f32_f32();
2991		assert_or_panic(s.a.b == 1.0f);
2992		assert_or_panic(s.a.c == 2.0f);
2993		assert_or_panic(s.d == 3.0f);
2994		zig_struct_f32f32_f32((struct Struct_f32f32_f32){ .a = { .b = 1.0f, .c = 2.0f }, .d = 3.0f });
2995		}
2996
2997		{
2998		struct Struct_f32_f32f32 s = zig_ret_struct_f32_f32f32();
2999		assert_or_panic(s.a == 1.0f);
3000		assert_or_panic(s.b.c == 2.0f);
3001		assert_or_panic(s.b.d == 3.0f);
3002		zig_struct_f32_f32f32((struct Struct_f32_f32f32){ .a = 1.0f, .b = { .c = 2.0f, .d = 3.0f } });
3003		}
3004		#endif
3005		#endif
3006
3007		#if !defined(__powerpc__) && !defined(__loongarch__) && !defined(__mips64__)
3008		#if !(defined(_WIN32) && defined(__i386__))
3009		{
3010		struct Struct_u32_Union_u32_u32u32 s = zig_ret_struct_u32_union_u32_u32u32();
3011		assert_or_panic(s.a == 1);
3012		assert_or_panic(s.b.c.d == 2);
3013		assert_or_panic(s.b.c.e == 3);
3014		zig_struct_u32_union_u32_u32u32(s);
3015		}
3016
3017		{
3018		struct Struct_i32_i32 s = {1, 2};
3019		zig_struct_i32_i32(s);
3020		}
3021		#endif
3022		#endif
3023	15391
3024		#if !defined(__powerpc64__) && !defined(__loongarch__) && !defined(__mips64__)
	15392	#ifndef __hexagon__
	15393	#ifndef __loongarch__
	15394	#ifndef ZIG_MIPS64
	15395	#ifndef __powerpc__
	15396	#ifndef __s390x__
3025	15397	{
3026	15398	struct BigStruct s = {1, 2, 3, 4, 5};
3027	15399	zig_big_struct(s);
3028	15400	}
3029	15401	#endif
3030	15402	#endif
3031
3032		#if !defined __i386__ && !defined __arm__ && \
3033		!defined __powerpc__ && !defined(__loongarch__) && \
3034		!defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__)
3035		{
3036		struct SmallStructInts s = {1, 2, 3, 4};
3037		zig_small_struct_ints(s);
3038		}
3039	15403	#endif
3040
3041		#if !defined __arm__ && \
3042		!defined __powerpc__ && !defined(__loongarch__) && \
3043		!defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__)
3044		{
3045		struct MedStructInts s = {1, 2, 3};
3046		zig_med_struct_ints(s);
3047		}
	15404	#endif
3048	15405	#endif
3049	15406
3050	15407	#ifndef ZIG_NO_I128
...	...	@@ -3065,34 +15422,60 @@ void run_c_tests(void) {
3065	15422	zig_small_packed_struct(s);
3066	15423	}
3067	15424
3068		#if !defined __i386__ && !defined __arm__ && \
3069		!defined ZIG_PPC32 && !defined _ARCH_PPC64 && !defined(__loongarch__) && \
3070		!defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__)
	15425	#ifndef __hexagon__
	15426	#ifndef __i386__
	15427	#ifndef __loongarch__
	15428	#ifndef ZIG_MIPS64
	15429	#ifndef __powerpc__
	15430	#ifndef __s390x__
3071	15431	{
3072	15432	struct SplitStructInts s = {1234, 100, 1337};
3073	15433	zig_split_struct_ints(s);
3074	15434	}
3075	15435	#endif
	15436	#endif
	15437	#endif
	15438	#endif
	15439	#endif
	15440	#endif
3076	15441
3077		#if !defined __arm__ && !defined ZIG_PPC32 && !defined _ARCH_PPC64 && !defined(__loongarch__) && \
3078		!defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__)
	15442	#ifndef __hexagon__
	15443	#ifndef __loongarch__
	15444	#ifndef ZIG_MIPS64
	15445	#ifndef __powerpc__
	15446	#ifndef __s390x__
3079	15447	{
3080	15448	struct MedStructMixed s = {1234, 100.0f, 1337.0f};
3081	15449	zig_med_struct_mixed(s);
3082	15450	}
3083	15451	#endif
	15452	#endif
	15453	#endif
	15454	#endif
	15455	#endif
3084	15456
3085		#if !defined __i386__ && !defined __arm__ && \
3086		!defined ZIG_PPC32 && !defined _ARCH_PPC64 && !defined(__loongarch__) && \
3087		!defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__)
	15457	#ifndef __hexagon__
	15458	#ifndef __i386__
	15459	#ifndef __loongarch__
	15460	#ifndef ZIG_MIPS64
	15461	#ifndef __powerpc__
	15462	#ifndef __s390x__
3088	15463	{
3089	15464	struct SplitStructMixed s = {1234, 100, 1337.0f};
3090	15465	zig_split_struct_mixed(s);
3091	15466	}
3092	15467	#endif
	15468	#endif
	15469	#endif
	15470	#endif
	15471	#endif
	15472	#endif
3093	15473
3094		#if !defined(__powerpc__) && !defined(__loongarch__) && !defined(__mips64__) && !defined(__hexagon__) && \
3095		!defined(__s390x__)
	15474	#ifndef __hexagon__
	15475	#ifndef __loongarch__
	15476	#ifndef ZIG_MIPS64
	15477	#ifndef __powerpc__
	15478	#ifndef __s390x__
3096	15479	{
3097	15480	struct BigStruct s = {30, 31, 32, 33, 34};
3098	15481	struct BigStruct res = zig_big_struct_both(s);
...	...	@@ -3103,23 +15486,9 @@ void run_c_tests(void) {
3103	15486	assert_or_panic(res.e == 24);
3104	15487	}
3105	15488	#endif
3106
3107		#if !defined ZIG_PPC32 && !defined _ARCH_PPC64 && !defined(__loongarch__) && !defined(__mips64__) && \
3108		!defined(__hexagon__) && !defined(__s390x__)
3109		{
3110		struct Rect r1 = {1, 21, 16, 4};
3111		struct Rect r2 = {178, 189, 21, 15};
3112		zig_multiple_struct_ints(r1, r2);
3113		}
3114	15489	#endif
3115
3116		#if !defined ZIG_PPC32 && !defined(__loongarch__) && !defined(__mips64__) && !defined(__hexagon__) && \
3117		!defined(__s390x__)
3118		{
3119		struct FloatRect r1 = {1, 21, 16, 4};
3120		struct FloatRect r2 = {178, 189, 21, 15};
3121		zig_multiple_struct_floats(r1, r2);
3122		}
	15490	#endif
	15491	#endif
3123	15492	#endif
3124	15493
3125	15494	{
...	...	@@ -3135,2107 +15504,6 @@ void run_c_tests(void) {
3135	15504	assert_or_panic(zig_ret_i32() == -1);
3136	15505	assert_or_panic(zig_ret_i64() == -1);
3137	15506	}
3138
3139		#if defined(ZIG_BACKEND_STAGE2_X86_64) \|\| defined(ZIG_PPC32)
3140		{
3141		zig_vector_2_bool((Vector2Bool){
3142		false,
3143		true,
3144		});
3145
3146		Vector2Bool vec = zig_ret_vector_2_bool();
3147		assert_or_panic(vec[0] == false);
3148		assert_or_panic(vec[1] == false);
3149		}
3150		{
3151		zig_vector_4_bool((Vector4Bool){
3152		false,
3153		false,
3154		false,
3155		false,
3156		});
3157
3158		Vector4Bool vec = zig_ret_vector_4_bool();
3159		assert_or_panic(vec[0] == false);
3160		assert_or_panic(vec[1] == true);
3161		assert_or_panic(vec[2] == true);
3162		assert_or_panic(vec[3] == true);
3163		}
3164		{
3165		zig_vector_8_bool((Vector8Bool){
3166		true,
3167		true,
3168		false,
3169		true,
3170		false,
3171		true,
3172		true,
3173		false,
3174		});
3175
3176		Vector8Bool vec = zig_ret_vector_8_bool();
3177		assert_or_panic(vec[0] == false);
3178		assert_or_panic(vec[1] == false);
3179		assert_or_panic(vec[2] == false);
3180		assert_or_panic(vec[3] == false);
3181		assert_or_panic(vec[4] == true);
3182		assert_or_panic(vec[5] == false);
3183		assert_or_panic(vec[6] == false);
3184		assert_or_panic(vec[7] == false);
3185		}
3186		{
3187		zig_vector_16_bool((Vector16Bool){
3188		true,
3189		false,
3190		true,
3191		true,
3192		true,
3193		false,
3194		false,
3195		false,
3196		true,
3197		true,
3198		true,
3199		true,
3200		false,
3201		false,
3202		false,
3203		true,
3204		});
3205
3206		Vector16Bool vec = zig_ret_vector_16_bool();
3207		assert_or_panic(vec[0] == false);
3208		assert_or_panic(vec[1] == true);
3209		assert_or_panic(vec[2] == false);
3210		assert_or_panic(vec[3] == false);
3211		assert_or_panic(vec[4] == false);
3212		assert_or_panic(vec[5] == true);
3213		assert_or_panic(vec[6] == false);
3214		assert_or_panic(vec[7] == false);
3215		assert_or_panic(vec[8] == true);
3216		assert_or_panic(vec[9] == false);
3217		assert_or_panic(vec[10] == false);
3218		assert_or_panic(vec[11] == false);
3219		assert_or_panic(vec[12] == false);
3220		assert_or_panic(vec[13] == true);
3221		assert_or_panic(vec[14] == false);
3222		assert_or_panic(vec[15] == false);
3223		}
3224		{
3225		zig_vector_32_bool((Vector32Bool){
3226		false,
3227		false,
3228		false,
3229		true,
3230		true,
3231		false,
3232		false,
3233		true,
3234		false,
3235		true,
3236		true,
3237		true,
3238		false,
3239		false,
3240		true,
3241		true,
3242		true,
3243		true,
3244		true,
3245		false,
3246		true,
3247		true,
3248		true,
3249		false,
3250		false,
3251		true,
3252		true,
3253		false,
3254		true,
3255		true,
3256		false,
3257		true,
3258		});
3259
3260		Vector32Bool vec = zig_ret_vector_32_bool();
3261		assert_or_panic(vec[0] == false);
3262		assert_or_panic(vec[1] == true);
3263		assert_or_panic(vec[2] == false);
3264		assert_or_panic(vec[3] == false);
3265		assert_or_panic(vec[4] == true);
3266		assert_or_panic(vec[5] == false);
3267		assert_or_panic(vec[6] == true);
3268		assert_or_panic(vec[7] == true);
3269		assert_or_panic(vec[8] == true);
3270		assert_or_panic(vec[9] == true);
3271		assert_or_panic(vec[10] == true);
3272		assert_or_panic(vec[11] == true);
3273		assert_or_panic(vec[12] == false);
3274		assert_or_panic(vec[13] == false);
3275		assert_or_panic(vec[14] == false);
3276		assert_or_panic(vec[15] == false);
3277		assert_or_panic(vec[16] == false);
3278		assert_or_panic(vec[17] == false);
3279		assert_or_panic(vec[18] == true);
3280		assert_or_panic(vec[19] == true);
3281		assert_or_panic(vec[20] == true);
3282		assert_or_panic(vec[21] == false);
3283		assert_or_panic(vec[22] == true);
3284		assert_or_panic(vec[23] == false);
3285		assert_or_panic(vec[24] == true);
3286		assert_or_panic(vec[25] == false);
3287		assert_or_panic(vec[26] == false);
3288		assert_or_panic(vec[27] == true);
3289		assert_or_panic(vec[28] == false);
3290		assert_or_panic(vec[29] == false);
3291		assert_or_panic(vec[30] == true);
3292		assert_or_panic(vec[31] == true);
3293		}
3294		{
3295		zig_vector_64_bool((Vector64Bool){
3296		true,
3297		true,
3298		false,
3299		true,
3300		false,
3301		true,
3302		false,
3303		false,
3304		true,
3305		true,
3306		true,
3307		true,
3308		true,
3309		true,
3310		true,
3311		false,
3312		false,
3313		true,
3314		true,
3315		false,
3316		true,
3317		true,
3318		true,
3319		true,
3320		false,
3321		false,
3322		true,
3323		false,
3324		false,
3325		true,
3326		false,
3327		true,
3328		false,
3329		true,
3330		true,
3331		false,
3332		true,
3333		true,
3334		false,
3335		false,
3336		true,
3337		true,
3338		true,
3339		true,
3340		true,
3341		false,
3342		true,
3343		false,
3344		false,
3345		false,
3346		false,
3347		false,
3348		true,
3349		false,
3350		false,
3351		true,
3352		true,
3353		false,
3354		false,
3355		false,
3356		true,
3357		true,
3358		true,
3359		true,
3360		});
3361
3362		Vector64Bool vec = zig_ret_vector_64_bool();
3363		assert_or_panic(vec[0] == true);
3364		assert_or_panic(vec[1] == false);
3365		assert_or_panic(vec[2] == true);
3366		assert_or_panic(vec[3] == false);
3367		assert_or_panic(vec[4] == false);
3368		assert_or_panic(vec[5] == true);
3369		assert_or_panic(vec[6] == false);
3370		assert_or_panic(vec[7] == true);
3371		assert_or_panic(vec[8] == true);
3372		assert_or_panic(vec[9] == false);
3373		assert_or_panic(vec[10] == true);
3374		assert_or_panic(vec[11] == false);
3375		assert_or_panic(vec[12] == true);
3376		assert_or_panic(vec[13] == false);
3377		assert_or_panic(vec[14] == false);
3378		assert_or_panic(vec[15] == true);
3379		assert_or_panic(vec[16] == false);
3380		assert_or_panic(vec[17] == false);
3381		assert_or_panic(vec[18] == true);
3382		assert_or_panic(vec[19] == true);
3383		assert_or_panic(vec[20] == false);
3384		assert_or_panic(vec[21] == false);
3385		assert_or_panic(vec[22] == true);
3386		assert_or_panic(vec[23] == false);
3387		assert_or_panic(vec[24] == false);
3388		assert_or_panic(vec[25] == true);
3389		assert_or_panic(vec[26] == true);
3390		assert_or_panic(vec[27] == true);
3391		assert_or_panic(vec[28] == true);
3392		assert_or_panic(vec[29] == true);
3393		assert_or_panic(vec[30] == false);
3394		assert_or_panic(vec[31] == false);
3395		assert_or_panic(vec[32] == true);
3396		assert_or_panic(vec[33] == true);
3397		assert_or_panic(vec[34] == true);
3398		assert_or_panic(vec[35] == true);
3399		assert_or_panic(vec[36] == false);
3400		assert_or_panic(vec[37] == true);
3401		assert_or_panic(vec[38] == false);
3402		assert_or_panic(vec[39] == true);
3403		assert_or_panic(vec[40] == true);
3404		assert_or_panic(vec[41] == true);
3405		assert_or_panic(vec[42] == true);
3406		assert_or_panic(vec[43] == true);
3407		assert_or_panic(vec[44] == false);
3408		assert_or_panic(vec[45] == false);
3409		assert_or_panic(vec[46] == false);
3410		assert_or_panic(vec[47] == true);
3411		assert_or_panic(vec[48] == true);
3412		assert_or_panic(vec[49] == true);
3413		assert_or_panic(vec[50] == false);
3414		assert_or_panic(vec[51] == true);
3415		assert_or_panic(vec[52] == true);
3416		assert_or_panic(vec[53] == true);
3417		assert_or_panic(vec[54] == false);
3418		assert_or_panic(vec[55] == false);
3419		assert_or_panic(vec[56] == false);
3420		assert_or_panic(vec[57] == true);
3421		assert_or_panic(vec[58] == false);
3422		assert_or_panic(vec[59] == false);
3423		assert_or_panic(vec[60] == true);
3424		assert_or_panic(vec[61] == false);
3425		assert_or_panic(vec[62] == true);
3426		assert_or_panic(vec[63] == false);
3427		}
3428		{
3429		zig_vector_128_bool((Vector128Bool){
3430		true,
3431		true,
3432		false,
3433		true,
3434		true,
3435		false,
3436		false,
3437		true,
3438		true,
3439		true,
3440		true,
3441		true,
3442		false,
3443		false,
3444		false,
3445		true,
3446		false,
3447		true,
3448		false,
3449		false,
3450		true,
3451		false,
3452		true,
3453		false,
3454		false,
3455		false,
3456		true,
3457		false,
3458		true,
3459		true,
3460		false,
3461		true,
3462		false,
3463		true,
3464		true,
3465		false,
3466		false,
3467		false,
3468		false,
3469		true,
3470		true,
3471		false,
3472		true,
3473		false,
3474		false,
3475		true,
3476		false,
3477		false,
3478		true,
3479		true,
3480		false,
3481		false,
3482		true,
3483		false,
3484		false,
3485		true,
3486		true,
3487		true,
3488		true,
3489		true,
3490		true,
3491		true,
3492		true,
3493		false,
3494		false,
3495		true,
3496		false,
3497		true,
3498		true,
3499		true,
3500		true,
3501		false,
3502		false,
3503		false,
3504		true,
3505		true,
3506		false,
3507		true,
3508		true,
3509		true,
3510		true,
3511		false,
3512		true,
3513		true,
3514		true,
3515		true,
3516		true,
3517		true,
3518		false,
3519		true,
3520		true,
3521		true,
3522		true,
3523		true,
3524		true,
3525		false,
3526		false,
3527		false,
3528		true,
3529		true,
3530		true,
3531		true,
3532		true,
3533		true,
3534		true,
3535		false,
3536		false,
3537		false,
3538		false,
3539		false,
3540		true,
3541		true,
3542		true,
3543		false,
3544		false,
3545		false,
3546		false,
3547		false,
3548		true,
3549		false,
3550		false,
3551		false,
3552		false,
3553		true,
3554		true,
3555		false,
3556		true,
3557		false,
3558		});
3559
3560		Vector128Bool vec = zig_ret_vector_128_bool();
3561		assert_or_panic(vec[0] == true);
3562		assert_or_panic(vec[1] == true);
3563		assert_or_panic(vec[2] == false);
3564		assert_or_panic(vec[3] == false);
3565		assert_or_panic(vec[4] == false);
3566		assert_or_panic(vec[5] == true);
3567		assert_or_panic(vec[6] == true);
3568		assert_or_panic(vec[7] == false);
3569		assert_or_panic(vec[8] == false);
3570		assert_or_panic(vec[9] == true);
3571		assert_or_panic(vec[10] == false);
3572		assert_or_panic(vec[11] == false);
3573		assert_or_panic(vec[12] == false);
3574		assert_or_panic(vec[13] == true);
3575		assert_or_panic(vec[14] == false);
3576		assert_or_panic(vec[15] == true);
3577		assert_or_panic(vec[16] == true);
3578		assert_or_panic(vec[17] == false);
3579		assert_or_panic(vec[18] == false);
3580		assert_or_panic(vec[19] == true);
3581		assert_or_panic(vec[20] == true);
3582		assert_or_panic(vec[21] == true);
3583		assert_or_panic(vec[22] == true);
3584		assert_or_panic(vec[23] == true);
3585		assert_or_panic(vec[24] == false);
3586		assert_or_panic(vec[25] == false);
3587		assert_or_panic(vec[26] == true);
3588		assert_or_panic(vec[27] == true);
3589		assert_or_panic(vec[28] == true);
3590		assert_or_panic(vec[29] == false);
3591		assert_or_panic(vec[30] == false);
3592		assert_or_panic(vec[31] == true);
3593		assert_or_panic(vec[32] == true);
3594		assert_or_panic(vec[33] == false);
3595		assert_or_panic(vec[34] == true);
3596		assert_or_panic(vec[35] == true);
3597		assert_or_panic(vec[36] == true);
3598		assert_or_panic(vec[37] == false);
3599		assert_or_panic(vec[38] == true);
3600		assert_or_panic(vec[39] == true);
3601		assert_or_panic(vec[40] == true);
3602		assert_or_panic(vec[41] == false);
3603		assert_or_panic(vec[42] == true);
3604		assert_or_panic(vec[43] == true);
3605		assert_or_panic(vec[44] == false);
3606		assert_or_panic(vec[45] == false);
3607		assert_or_panic(vec[46] == false);
3608		assert_or_panic(vec[47] == true);
3609		assert_or_panic(vec[48] == false);
3610		assert_or_panic(vec[49] == false);
3611		assert_or_panic(vec[50] == false);
3612		assert_or_panic(vec[51] == false);
3613		assert_or_panic(vec[52] == true);
3614		assert_or_panic(vec[53] == false);
3615		assert_or_panic(vec[54] == true);
3616		assert_or_panic(vec[55] == false);
3617		assert_or_panic(vec[56] == true);
3618		assert_or_panic(vec[57] == false);
3619		assert_or_panic(vec[58] == false);
3620		assert_or_panic(vec[59] == true);
3621		assert_or_panic(vec[60] == true);
3622		assert_or_panic(vec[61] == true);
3623		assert_or_panic(vec[62] == true);
3624		assert_or_panic(vec[63] == true);
3625		assert_or_panic(vec[64] == false);
3626		assert_or_panic(vec[65] == false);
3627		assert_or_panic(vec[66] == false);
3628		assert_or_panic(vec[67] == true);
3629		assert_or_panic(vec[68] == true);
3630		assert_or_panic(vec[69] == false);
3631		assert_or_panic(vec[70] == true);
3632		assert_or_panic(vec[71] == true);
3633		assert_or_panic(vec[72] == false);
3634		assert_or_panic(vec[73] == true);
3635		assert_or_panic(vec[74] == true);
3636		assert_or_panic(vec[75] == false);
3637		assert_or_panic(vec[76] == false);
3638		assert_or_panic(vec[77] == true);
3639		assert_or_panic(vec[78] == false);
3640		assert_or_panic(vec[79] == true);
3641		assert_or_panic(vec[80] == false);
3642		assert_or_panic(vec[81] == false);
3643		assert_or_panic(vec[82] == true);
3644		assert_or_panic(vec[83] == true);
3645		assert_or_panic(vec[84] == false);
3646		assert_or_panic(vec[85] == true);
3647		assert_or_panic(vec[86] == false);
3648		assert_or_panic(vec[87] == false);
3649		assert_or_panic(vec[88] == true);
3650		assert_or_panic(vec[89] == true);
3651		assert_or_panic(vec[90] == true);
3652		assert_or_panic(vec[91] == true);
3653		assert_or_panic(vec[92] == true);
3654		assert_or_panic(vec[93] == false);
3655		assert_or_panic(vec[94] == false);
3656		assert_or_panic(vec[95] == true);
3657		assert_or_panic(vec[96] == false);
3658		assert_or_panic(vec[97] == false);
3659		assert_or_panic(vec[98] == true);
3660		assert_or_panic(vec[99] == true);
3661		assert_or_panic(vec[100] == true);
3662		assert_or_panic(vec[101] == true);
3663		assert_or_panic(vec[102] == true);
3664		assert_or_panic(vec[103] == true);
3665		assert_or_panic(vec[104] == true);
3666		assert_or_panic(vec[105] == false);
3667		assert_or_panic(vec[106] == false);
3668		assert_or_panic(vec[107] == true);
3669		assert_or_panic(vec[108] == false);
3670		assert_or_panic(vec[109] == false);
3671		assert_or_panic(vec[110] == true);
3672		assert_or_panic(vec[111] == false);
3673		assert_or_panic(vec[112] == false);
3674		assert_or_panic(vec[113] == true);
3675		assert_or_panic(vec[114] == false);
3676		assert_or_panic(vec[115] == false);
3677		assert_or_panic(vec[116] == false);
3678		assert_or_panic(vec[117] == false);
3679		assert_or_panic(vec[118] == false);
3680		assert_or_panic(vec[119] == false);
3681		assert_or_panic(vec[120] == true);
3682		assert_or_panic(vec[121] == true);
3683		assert_or_panic(vec[122] == true);
3684		assert_or_panic(vec[123] == false);
3685		assert_or_panic(vec[124] == true);
3686		assert_or_panic(vec[125] == false);
3687		assert_or_panic(vec[126] == false);
3688		assert_or_panic(vec[127] == true);
3689		}
3690		{
3691		zig_vector_256_bool((Vector256Bool){
3692		false,
3693		false,
3694		false,
3695		false,
3696		true,
3697		true,
3698		false,
3699		false,
3700		false,
3701		true,
3702		true,
3703		false,
3704		true,
3705		false,
3706		false,
3707		false,
3708		false,
3709		true,
3710		true,
3711		true,
3712		false,
3713		true,
3714		true,
3715		false,
3716		true,
3717		false,
3718		false,
3719		true,
3720		true,
3721		true,
3722		false,
3723		true,
3724		false,
3725		true,
3726		false,
3727		false,
3728		false,
3729		true,
3730		false,
3731		false,
3732		true,
3733		true,
3734		false,
3735		true,
3736		true,
3737		false,
3738		true,
3739		false,
3740		true,
3741		false,
3742		true,
3743		false,
3744		true,
3745		true,
3746		true,
3747		false,
3748		false,
3749		true,
3750		true,
3751		false,
3752		false,
3753		true,
3754		true,
3755		false,
3756		false,
3757		false,
3758		true,
3759		true,
3760		false,
3761		true,
3762		false,
3763		true,
3764		false,
3765		true,
3766		false,
3767		false,
3768		true,
3769		false,
3770		false,
3771		false,
3772		false,
3773		false,
3774		true,
3775		false,
3776		false,
3777		false,
3778		true,
3779		true,
3780		true,
3781		false,
3782		true,
3783		false,
3784		true,
3785		false,
3786		true,
3787		true,
3788		true,
3789		true,
3790		false,
3791		true,
3792		false,
3793		true,
3794		true,
3795		false,
3796		false,
3797		true,
3798		false,
3799		true,
3800		false,
3801		false,
3802		false,
3803		false,
3804		false,
3805		false,
3806		false,
3807		false,
3808		false,
3809		false,
3810		false,
3811		false,
3812		false,
3813		false,
3814		true,
3815		true,
3816		false,
3817		false,
3818		false,
3819		true,
3820		true,
3821		true,
3822		true,
3823		false,
3824		false,
3825		false,
3826		true,
3827		true,
3828		false,
3829		false,
3830		true,
3831		true,
3832		true,
3833		true,
3834		true,
3835		false,
3836		true,
3837		true,
3838		true,
3839		false,
3840		false,
3841		false,
3842		false,
3843		false,
3844		false,
3845		false,
3846		true,
3847		false,
3848		false,
3849		false,
3850		true,
3851		true,
3852		false,
3853		true,
3854		false,
3855		false,
3856		false,
3857		true,
3858		false,
3859		true,
3860		false,
3861		false,
3862		false,
3863		false,
3864		true,
3865		true,
3866		true,
3867		true,
3868		true,
3869		true,
3870		false,
3871		true,
3872		true,
3873		false,
3874		true,
3875		false,
3876		true,
3877		false,
3878		true,
3879		false,
3880		true,
3881		false,
3882		false,
3883		false,
3884		false,
3885		true,
3886		true,
3887		true,
3888		false,
3889		false,
3890		true,
3891		false,
3892		false,
3893		true,
3894		true,
3895		false,
3896		true,
3897		false,
3898		true,
3899		false,
3900		false,
3901		false,
3902		true,
3903		true,
3904		false,
3905		false,
3906		false,
3907		true,
3908		false,
3909		true,
3910		true,
3911		true,
3912		false,
3913		true,
3914		false,
3915		true,
3916		false,
3917		false,
3918		false,
3919		true,
3920		true,
3921		false,
3922		false,
3923		false,
3924		false,
3925		false,
3926		true,
3927		false,
3928		false,
3929		false,
3930		true,
3931		false,
3932		true,
3933		true,
3934		true,
3935		false,
3936		false,
3937		true,
3938		false,
3939		false,
3940		false,
3941		true,
3942		false,
3943		false,
3944		true,
3945		true,
3946		true,
3947		true,
3948		});
3949
3950		Vector256Bool vec = zig_ret_vector_256_bool();
3951		assert_or_panic(vec[0] == true);
3952		assert_or_panic(vec[1] == true);
3953		assert_or_panic(vec[2] == true);
3954		assert_or_panic(vec[3] == false);
3955		assert_or_panic(vec[4] == true);
3956		assert_or_panic(vec[5] == false);
3957		assert_or_panic(vec[6] == false);
3958		assert_or_panic(vec[7] == true);
3959		assert_or_panic(vec[8] == false);
3960		assert_or_panic(vec[9] == false);
3961		assert_or_panic(vec[10] == false);
3962		assert_or_panic(vec[11] == false);
3963		assert_or_panic(vec[12] == false);
3964		assert_or_panic(vec[13] == false);
3965		assert_or_panic(vec[14] == false);
3966		assert_or_panic(vec[15] == false);
3967		assert_or_panic(vec[16] == true);
3968		assert_or_panic(vec[17] == false);
3969		assert_or_panic(vec[18] == true);
3970		assert_or_panic(vec[19] == false);
3971		assert_or_panic(vec[20] == false);
3972		assert_or_panic(vec[21] == true);
3973		assert_or_panic(vec[22] == true);
3974		assert_or_panic(vec[23] == false);
3975		assert_or_panic(vec[24] == false);
3976		assert_or_panic(vec[25] == true);
3977		assert_or_panic(vec[26] == true);
3978		assert_or_panic(vec[27] == false);
3979		assert_or_panic(vec[28] == true);
3980		assert_or_panic(vec[29] == true);
3981		assert_or_panic(vec[30] == true);
3982		assert_or_panic(vec[31] == false);
3983		assert_or_panic(vec[32] == true);
3984		assert_or_panic(vec[33] == false);
3985		assert_or_panic(vec[34] == true);
3986		assert_or_panic(vec[35] == false);
3987		assert_or_panic(vec[36] == true);
3988		assert_or_panic(vec[37] == false);
3989		assert_or_panic(vec[38] == true);
3990		assert_or_panic(vec[39] == false);
3991		assert_or_panic(vec[40] == false);
3992		assert_or_panic(vec[41] == false);
3993		assert_or_panic(vec[42] == true);
3994		assert_or_panic(vec[43] == true);
3995		assert_or_panic(vec[44] == true);
3996		assert_or_panic(vec[45] == false);
3997		assert_or_panic(vec[46] == false);
3998		assert_or_panic(vec[47] == false);
3999		assert_or_panic(vec[48] == true);
4000		assert_or_panic(vec[49] == false);
4001		assert_or_panic(vec[50] == true);
4002		assert_or_panic(vec[51] == false);
4003		assert_or_panic(vec[52] == true);
4004		assert_or_panic(vec[53] == false);
4005		assert_or_panic(vec[54] == true);
4006		assert_or_panic(vec[55] == true);
4007		assert_or_panic(vec[56] == false);
4008		assert_or_panic(vec[57] == false);
4009		assert_or_panic(vec[58] == false);
4010		assert_or_panic(vec[59] == true);
4011		assert_or_panic(vec[60] == true);
4012		assert_or_panic(vec[61] == true);
4013		assert_or_panic(vec[62] == false);
4014		assert_or_panic(vec[63] == true);
4015		assert_or_panic(vec[64] == false);
4016		assert_or_panic(vec[65] == true);
4017		assert_or_panic(vec[66] == false);
4018		assert_or_panic(vec[67] == true);
4019		assert_or_panic(vec[68] == true);
4020		assert_or_panic(vec[69] == false);
4021		assert_or_panic(vec[70] == true);
4022		assert_or_panic(vec[71] == false);
4023		assert_or_panic(vec[72] == true);
4024		assert_or_panic(vec[73] == true);
4025		assert_or_panic(vec[74] == false);
4026		assert_or_panic(vec[75] == false);
4027		assert_or_panic(vec[76] == false);
4028		assert_or_panic(vec[77] == false);
4029		assert_or_panic(vec[78] == false);
4030		assert_or_panic(vec[79] == false);
4031		assert_or_panic(vec[80] == false);
4032		assert_or_panic(vec[81] == false);
4033		assert_or_panic(vec[82] == false);
4034		assert_or_panic(vec[83] == true);
4035		assert_or_panic(vec[84] == false);
4036		assert_or_panic(vec[85] == false);
4037		assert_or_panic(vec[86] == false);
4038		assert_or_panic(vec[87] == true);
4039		assert_or_panic(vec[88] == false);
4040		assert_or_panic(vec[89] == true);
4041		assert_or_panic(vec[90] == true);
4042		assert_or_panic(vec[91] == false);
4043		assert_or_panic(vec[92] == false);
4044		assert_or_panic(vec[93] == true);
4045		assert_or_panic(vec[94] == true);
4046		assert_or_panic(vec[95] == false);
4047		assert_or_panic(vec[96] == false);
4048		assert_or_panic(vec[97] == true);
4049		assert_or_panic(vec[98] == false);
4050		assert_or_panic(vec[99] == false);
4051		assert_or_panic(vec[100] == false);
4052		assert_or_panic(vec[101] == false);
4053		assert_or_panic(vec[102] == false);
4054		assert_or_panic(vec[103] == false);
4055		assert_or_panic(vec[104] == false);
4056		assert_or_panic(vec[105] == true);
4057		assert_or_panic(vec[106] == true);
4058		assert_or_panic(vec[107] == false);
4059		assert_or_panic(vec[108] == true);
4060		assert_or_panic(vec[109] == false);
4061		assert_or_panic(vec[110] == true);
4062		assert_or_panic(vec[111] == true);
4063		assert_or_panic(vec[112] == false);
4064		assert_or_panic(vec[113] == false);
4065		assert_or_panic(vec[114] == false);
4066		assert_or_panic(vec[115] == false);
4067		assert_or_panic(vec[116] == false);
4068		assert_or_panic(vec[117] == false);
4069		assert_or_panic(vec[118] == false);
4070		assert_or_panic(vec[119] == true);
4071		assert_or_panic(vec[120] == true);
4072		assert_or_panic(vec[121] == true);
4073		assert_or_panic(vec[122] == false);
4074		assert_or_panic(vec[123] == true);
4075		assert_or_panic(vec[124] == true);
4076		assert_or_panic(vec[125] == false);
4077		assert_or_panic(vec[126] == false);
4078		assert_or_panic(vec[127] == true);
4079		assert_or_panic(vec[128] == true);
4080		assert_or_panic(vec[129] == true);
4081		assert_or_panic(vec[130] == true);
4082		assert_or_panic(vec[131] == true);
4083		assert_or_panic(vec[132] == false);
4084		assert_or_panic(vec[133] == true);
4085		assert_or_panic(vec[134] == true);
4086		assert_or_panic(vec[135] == false);
4087		assert_or_panic(vec[136] == false);
4088		assert_or_panic(vec[137] == true);
4089		assert_or_panic(vec[138] == true);
4090		assert_or_panic(vec[139] == false);
4091		assert_or_panic(vec[140] == true);
4092		assert_or_panic(vec[141] == false);
4093		assert_or_panic(vec[142] == true);
4094		assert_or_panic(vec[143] == false);
4095		assert_or_panic(vec[144] == true);
4096		assert_or_panic(vec[145] == true);
4097		assert_or_panic(vec[146] == true);
4098		assert_or_panic(vec[147] == true);
4099		assert_or_panic(vec[148] == false);
4100		assert_or_panic(vec[149] == false);
4101		assert_or_panic(vec[150] == false);
4102		assert_or_panic(vec[151] == true);
4103		assert_or_panic(vec[152] == false);
4104		assert_or_panic(vec[153] == true);
4105		assert_or_panic(vec[154] == false);
4106		assert_or_panic(vec[155] == true);
4107		assert_or_panic(vec[156] == true);
4108		assert_or_panic(vec[157] == false);
4109		assert_or_panic(vec[158] == true);
4110		assert_or_panic(vec[159] == true);
4111		assert_or_panic(vec[160] == true);
4112		assert_or_panic(vec[161] == true);
4113		assert_or_panic(vec[162] == true);
4114		assert_or_panic(vec[163] == false);
4115		assert_or_panic(vec[164] == false);
4116		assert_or_panic(vec[165] == true);
4117		assert_or_panic(vec[166] == false);
4118		assert_or_panic(vec[167] == true);
4119		assert_or_panic(vec[168] == true);
4120		assert_or_panic(vec[169] == true);
4121		assert_or_panic(vec[170] == true);
4122		assert_or_panic(vec[171] == false);
4123		assert_or_panic(vec[172] == true);
4124		assert_or_panic(vec[173] == true);
4125		assert_or_panic(vec[174] == true);
4126		assert_or_panic(vec[175] == true);
4127		assert_or_panic(vec[176] == true);
4128		assert_or_panic(vec[177] == true);
4129		assert_or_panic(vec[178] == true);
4130		assert_or_panic(vec[179] == false);
4131		assert_or_panic(vec[180] == true);
4132		assert_or_panic(vec[181] == false);
4133		assert_or_panic(vec[182] == false);
4134		assert_or_panic(vec[183] == false);
4135		assert_or_panic(vec[184] == true);
4136		assert_or_panic(vec[185] == false);
4137		assert_or_panic(vec[186] == true);
4138		assert_or_panic(vec[187] == true);
4139		assert_or_panic(vec[188] == false);
4140		assert_or_panic(vec[189] == true);
4141		assert_or_panic(vec[190] == false);
4142		assert_or_panic(vec[191] == true);
4143		assert_or_panic(vec[192] == false);
4144		assert_or_panic(vec[193] == true);
4145		assert_or_panic(vec[194] == false);
4146		assert_or_panic(vec[195] == false);
4147		assert_or_panic(vec[196] == true);
4148		assert_or_panic(vec[197] == true);
4149		assert_or_panic(vec[198] == true);
4150		assert_or_panic(vec[199] == true);
4151		assert_or_panic(vec[200] == true);
4152		assert_or_panic(vec[201] == true);
4153		assert_or_panic(vec[202] == true);
4154		assert_or_panic(vec[203] == false);
4155		assert_or_panic(vec[204] == true);
4156		assert_or_panic(vec[205] == false);
4157		assert_or_panic(vec[206] == false);
4158		assert_or_panic(vec[207] == true);
4159		assert_or_panic(vec[208] == true);
4160		assert_or_panic(vec[209] == false);
4161		assert_or_panic(vec[210] == false);
4162		assert_or_panic(vec[211] == false);
4163		assert_or_panic(vec[212] == true);
4164		assert_or_panic(vec[213] == true);
4165		assert_or_panic(vec[214] == true);
4166		assert_or_panic(vec[215] == false);
4167		assert_or_panic(vec[216] == false);
4168		assert_or_panic(vec[217] == true);
4169		assert_or_panic(vec[218] == true);
4170		assert_or_panic(vec[219] == true);
4171		assert_or_panic(vec[220] == true);
4172		assert_or_panic(vec[221] == false);
4173		assert_or_panic(vec[222] == true);
4174		assert_or_panic(vec[223] == false);
4175		assert_or_panic(vec[224] == true);
4176		assert_or_panic(vec[225] == true);
4177		assert_or_panic(vec[226] == true);
4178		assert_or_panic(vec[227] == false);
4179		assert_or_panic(vec[228] == false);
4180		assert_or_panic(vec[229] == false);
4181		assert_or_panic(vec[230] == false);
4182		assert_or_panic(vec[231] == false);
4183		assert_or_panic(vec[232] == true);
4184		assert_or_panic(vec[233] == true);
4185		assert_or_panic(vec[234] == false);
4186		assert_or_panic(vec[235] == false);
4187		assert_or_panic(vec[236] == false);
4188		assert_or_panic(vec[237] == true);
4189		assert_or_panic(vec[238] == true);
4190		assert_or_panic(vec[239] == false);
4191		assert_or_panic(vec[240] == true);
4192		assert_or_panic(vec[241] == true);
4193		assert_or_panic(vec[242] == true);
4194		assert_or_panic(vec[243] == false);
4195		assert_or_panic(vec[244] == true);
4196		assert_or_panic(vec[245] == true);
4197		assert_or_panic(vec[246] == false);
4198		assert_or_panic(vec[247] == true);
4199		assert_or_panic(vec[248] == false);
4200		assert_or_panic(vec[249] == false);
4201		assert_or_panic(vec[250] == true);
4202		assert_or_panic(vec[251] == true);
4203		assert_or_panic(vec[252] == false);
4204		assert_or_panic(vec[253] == true);
4205		assert_or_panic(vec[254] == false);
4206		assert_or_panic(vec[255] == true);
4207		}
4208		{
4209		zig_vector_512_bool((Vector512Bool){
4210		false,
4211		true,
4212		true,
4213		false,
4214		true,
4215		false,
4216		true,
4217		false,
4218		false,
4219		false,
4220		false,
4221		false,
4222		true,
4223		false,
4224		true,
4225		false,
4226		false,
4227		false,
4228		true,
4229		true,
4230		true,
4231		true,
4232		false,
4233		false,
4234		false,
4235		true,
4236		true,
4237		false,
4238		true,
4239		true,
4240		false,
4241		false,
4242		true,
4243		true,
4244		false,
4245		false,
4246		false,
4247		false,
4248		false,
4249		false,
4250		false,
4251		true,
4252		true,
4253		true,
4254		false,
4255		true,
4256		true,
4257		true,
4258		true,
4259		true,
4260		false,
4261		true,
4262		true,
4263		true,
4264		false,
4265		true,
4266		false,
4267		false,
4268		true,
4269		false,
4270		true,
4271		true,
4272		false,
4273		false,
4274		false,
4275		true,
4276		true,
4277		true,
4278		true,
4279		false,
4280		false,
4281		true,
4282		true,
4283		false,
4284		true,
4285		true,
4286		false,
4287		false,
4288		true,
4289		false,
4290		false,
4291		false,
4292		true,
4293		true,
4294		true,
4295		false,
4296		false,
4297		true,
4298		false,
4299		true,
4300		false,
4301		false,
4302		true,
4303		false,
4304		false,
4305		true,
4306		true,
4307		false,
4308		false,
4309		false,
4310		false,
4311		true,
4312		false,
4313		false,
4314		false,
4315		false,
4316		false,
4317		false,
4318		true,
4319		true,
4320		true,
4321		true,
4322		true,
4323		false,
4324		false,
4325		false,
4326		false,
4327		true,
4328		true,
4329		false,
4330		true,
4331		true,
4332		false,
4333		false,
4334		true,
4335		false,
4336		false,
4337		false,
4338		false,
4339		true,
4340		true,
4341		true,
4342		true,
4343		false,
4344		false,
4345		false,
4346		false,
4347		true,
4348		false,
4349		false,
4350		false,
4351		false,
4352		true,
4353		true,
4354		false,
4355		true,
4356		false,
4357		true,
4358		false,
4359		false,
4360		true,
4361		true,
4362		false,
4363		true,
4364		true,
4365		false,
4366		false,
4367		false,
4368		true,
4369		false,
4370		false,
4371		false,
4372		false,
4373		true,
4374		true,
4375		false,
4376		false,
4377		true,
4378		false,
4379		true,
4380		true,
4381		false,
4382		false,
4383		false,
4384		false,
4385		false,
4386		false,
4387		true,
4388		false,
4389		false,
4390		false,
4391		false,
4392		false,
4393		false,
4394		true,
4395		false,
4396		false,
4397		false,
4398		false,
4399		true,
4400		false,
4401		false,
4402		false,
4403		false,
4404		false,
4405		false,
4406		true,
4407		true,
4408		true,
4409		false,
4410		true,
4411		true,
4412		false,
4413		false,
4414		false,
4415		false,
4416		false,
4417		true,
4418		true,
4419		false,
4420		false,
4421		false,
4422		true,
4423		false,
4424		false,
4425		true,
4426		true,
4427		true,
4428		false,
4429		false,
4430		true,
4431		false,
4432		true,
4433		true,
4434		true,
4435		true,
4436		false,
4437		true,
4438		false,
4439		false,
4440		false,
4441		true,
4442		false,
4443		false,
4444		false,
4445		false,
4446		false,
4447		false,
4448		false,
4449		true,
4450		false,
4451		false,
4452		false,
4453		true,
4454		true,
4455		true,
4456		true,
4457		false,
4458		true,
4459		true,
4460		false,
4461		false,
4462		false,
4463		true,
4464		false,
4465		false,
4466		true,
4467		true,
4468		false,
4469		true,
4470		false,
4471		true,
4472		true,
4473		false,
4474		false,
4475		false,
4476		false,
4477		true,
4478		false,
4479		true,
4480		true,
4481		false,
4482		false,
4483		true,
4484		true,
4485		true,
4486		false,
4487		true,
4488		false,
4489		false,
4490		true,
4491		true,
4492		false,
4493		true,
4494		false,
4495		true,
4496		true,
4497		true,
4498		true,
4499		true,
4500		true,
4501		true,
4502		true,
4503		true,
4504		true,
4505		false,
4506		true,
4507		false,
4508		true,
4509		false,
4510		true,
4511		true,
4512		false,
4513		true,
4514		false,
4515		true,
4516		false,
4517		true,
4518		true,
4519		false,
4520		true,
4521		true,
4522		true,
4523		false,
4524		false,
4525		false,
4526		false,
4527		true,
4528		true,
4529		true,
4530		true,
4531		true,
4532		true,
4533		true,
4534		true,
4535		true,
4536		false,
4537		true,
4538		false,
4539		false,
4540		true,
4541		false,
4542		false,
4543		false,
4544		false,
4545		false,
4546		false,
4547		false,
4548		false,
4549		false,
4550		false,
4551		false,
4552		true,
4553		true,
4554		false,
4555		false,
4556		false,
4557		false,
4558		false,
4559		true,
4560		true,
4561		true,
4562		true,
4563		false,
4564		false,
4565		false,
4566		false,
4567		true,
4568		true,
4569		false,
4570		false,
4571		false,
4572		true,
4573		true,
4574		false,
4575		false,
4576		false,
4577		false,
4578		false,
4579		true,
4580		true,
4581		false,
4582		true,
4583		true,
4584		false,
4585		true,
4586		true,
4587		false,
4588		true,
4589		true,
4590		false,
4591		true,
4592		true,
4593		false,
4594		true,
4595		false,
4596		true,
4597		true,
4598		true,
4599		true,
4600		false,
4601		false,
4602		false,
4603		true,
4604		true,
4605		true,
4606		true,
4607		false,
4608		true,
4609		true,
4610		true,
4611		false,
4612		false,
4613		true,
4614		false,
4615		false,
4616		false,
4617		true,
4618		true,
4619		true,
4620		false,
4621		true,
4622		false,
4623		false,
4624		false,
4625		true,
4626		false,
4627		false,
4628		true,
4629		true,
4630		true,
4631		true,
4632		false,
4633		true,
4634		true,
4635		false,
4636		false,
4637		false,
4638		true,
4639		false,
4640		true,
4641		true,
4642		false,
4643		false,
4644		false,
4645		false,
4646		true,
4647		false,
4648		true,
4649		false,
4650		false,
4651		false,
4652		false,
4653		true,
4654		false,
4655		false,
4656		true,
4657		true,
4658		true,
4659		false,
4660		true,
4661		true,
4662		false,
4663		true,
4664		false,
4665		true,
4666		false,
4667		false,
4668		false,
4669		true,
4670		false,
4671		false,
4672		false,
4673		true,
4674		true,
4675		true,
4676		true,
4677		true,
4678		false,
4679		false,
4680		false,
4681		false,
4682		false,
4683		false,
4684		true,
4685		true,
4686		true,
4687		true,
4688		true,
4689		false,
4690		true,
4691		true,
4692		false,
4693		true,
4694		false,
4695		true,
4696		false,
4697		true,
4698		false,
4699		false,
4700		false,
4701		true,
4702		false,
4703		false,
4704		false,
4705		true,
4706		true,
4707		false,
4708		false,
4709		true,
4710		false,
4711		true,
4712		false,
4713		false,
4714		false,
4715		true,
4716		true,
4717		true,
4718		true,
4719		false,
4720		false,
4721		true,
4722		});
4723
4724		Vector512Bool vec = zig_ret_vector_512_bool();
4725		assert_or_panic(vec[0] == true);
4726		assert_or_panic(vec[1] == true);
4727		assert_or_panic(vec[2] == true);
4728		assert_or_panic(vec[3] == true);
4729		assert_or_panic(vec[4] == false);
4730		assert_or_panic(vec[5] == true);
4731		assert_or_panic(vec[6] == false);
4732		assert_or_panic(vec[7] == true);
4733		assert_or_panic(vec[8] == true);
4734		assert_or_panic(vec[9] == true);
4735		assert_or_panic(vec[10] == false);
4736		assert_or_panic(vec[11] == true);
4737		assert_or_panic(vec[12] == false);
4738		assert_or_panic(vec[13] == false);
4739		assert_or_panic(vec[14] == false);
4740		assert_or_panic(vec[15] == true);
4741		assert_or_panic(vec[16] == true);
4742		assert_or_panic(vec[17] == false);
4743		assert_or_panic(vec[18] == false);
4744		assert_or_panic(vec[19] == false);
4745		assert_or_panic(vec[20] == true);
4746		assert_or_panic(vec[21] == true);
4747		assert_or_panic(vec[22] == false);
4748		assert_or_panic(vec[23] == false);
4749		assert_or_panic(vec[24] == false);
4750		assert_or_panic(vec[25] == false);
4751		assert_or_panic(vec[26] == true);
4752		assert_or_panic(vec[27] == false);
4753		assert_or_panic(vec[28] == false);
4754		assert_or_panic(vec[29] == false);
4755		assert_or_panic(vec[30] == true);
4756		assert_or_panic(vec[31] == true);
4757		assert_or_panic(vec[32] == true);
4758		assert_or_panic(vec[33] == true);
4759		assert_or_panic(vec[34] == false);
4760		assert_or_panic(vec[35] == false);
4761		assert_or_panic(vec[36] == false);
4762		assert_or_panic(vec[37] == true);
4763		assert_or_panic(vec[38] == true);
4764		assert_or_panic(vec[39] == true);
4765		assert_or_panic(vec[40] == false);
4766		assert_or_panic(vec[41] == false);
4767		assert_or_panic(vec[42] == true);
4768		assert_or_panic(vec[43] == false);
4769		assert_or_panic(vec[44] == false);
4770		assert_or_panic(vec[45] == true);
4771		assert_or_panic(vec[46] == false);
4772		assert_or_panic(vec[47] == false);
4773		assert_or_panic(vec[48] == true);
4774		assert_or_panic(vec[49] == true);
4775		assert_or_panic(vec[50] == true);
4776		assert_or_panic(vec[51] == true);
4777		assert_or_panic(vec[52] == false);
4778		assert_or_panic(vec[53] == false);
4779		assert_or_panic(vec[54] == false);
4780		assert_or_panic(vec[55] == true);
4781		assert_or_panic(vec[56] == false);
4782		assert_or_panic(vec[57] == true);
4783		assert_or_panic(vec[58] == false);
4784		assert_or_panic(vec[59] == true);
4785		assert_or_panic(vec[60] == true);
4786		assert_or_panic(vec[61] == false);
4787		assert_or_panic(vec[62] == false);
4788		assert_or_panic(vec[63] == true);
4789		assert_or_panic(vec[64] == true);
4790		assert_or_panic(vec[65] == false);
4791		assert_or_panic(vec[66] == true);
4792		assert_or_panic(vec[67] == false);
4793		assert_or_panic(vec[68] == false);
4794		assert_or_panic(vec[69] == false);
4795		assert_or_panic(vec[70] == true);
4796		assert_or_panic(vec[71] == true);
4797		assert_or_panic(vec[72] == true);
4798		assert_or_panic(vec[73] == true);
4799		assert_or_panic(vec[74] == true);
4800		assert_or_panic(vec[75] == false);
4801		assert_or_panic(vec[76] == true);
4802		assert_or_panic(vec[77] == false);
4803		assert_or_panic(vec[78] == true);
4804		assert_or_panic(vec[79] == true);
4805		assert_or_panic(vec[80] == true);
4806		assert_or_panic(vec[81] == true);
4807		assert_or_panic(vec[82] == true);
4808		assert_or_panic(vec[83] == false);
4809		assert_or_panic(vec[84] == true);
4810		assert_or_panic(vec[85] == true);
4811		assert_or_panic(vec[86] == false);
4812		assert_or_panic(vec[87] == true);
4813		assert_or_panic(vec[88] == false);
4814		assert_or_panic(vec[89] == false);
4815		assert_or_panic(vec[90] == true);
4816		assert_or_panic(vec[91] == false);
4817		assert_or_panic(vec[92] == true);
4818		assert_or_panic(vec[93] == false);
4819		assert_or_panic(vec[94] == false);
4820		assert_or_panic(vec[95] == false);
4821		assert_or_panic(vec[96] == true);
4822		assert_or_panic(vec[97] == true);
4823		assert_or_panic(vec[98] == false);
4824		assert_or_panic(vec[99] == true);
4825		assert_or_panic(vec[100] == true);
4826		assert_or_panic(vec[101] == false);
4827		assert_or_panic(vec[102] == true);
4828		assert_or_panic(vec[103] == false);
4829		assert_or_panic(vec[104] == true);
4830		assert_or_panic(vec[105] == false);
4831		assert_or_panic(vec[106] == true);
4832		assert_or_panic(vec[107] == false);
4833		assert_or_panic(vec[108] == false);
4834		assert_or_panic(vec[109] == true);
4835		assert_or_panic(vec[110] == false);
4836		assert_or_panic(vec[111] == false);
4837		assert_or_panic(vec[112] == true);
4838		assert_or_panic(vec[113] == false);
4839		assert_or_panic(vec[114] == true);
4840		assert_or_panic(vec[115] == false);
4841		assert_or_panic(vec[116] == true);
4842		assert_or_panic(vec[117] == false);
4843		assert_or_panic(vec[118] == false);
4844		assert_or_panic(vec[119] == true);
4845		assert_or_panic(vec[120] == true);
4846		assert_or_panic(vec[121] == true);
4847		assert_or_panic(vec[122] == false);
4848		assert_or_panic(vec[123] == true);
4849		assert_or_panic(vec[124] == false);
4850		assert_or_panic(vec[125] == false);
4851		assert_or_panic(vec[126] == true);
4852		assert_or_panic(vec[127] == true);
4853		assert_or_panic(vec[128] == false);
4854		assert_or_panic(vec[129] == true);
4855		assert_or_panic(vec[130] == true);
4856		assert_or_panic(vec[131] == false);
4857		assert_or_panic(vec[132] == true);
4858		assert_or_panic(vec[133] == true);
4859		assert_or_panic(vec[134] == false);
4860		assert_or_panic(vec[135] == true);
4861		assert_or_panic(vec[136] == true);
4862		assert_or_panic(vec[137] == false);
4863		assert_or_panic(vec[138] == false);
4864		assert_or_panic(vec[139] == false);
4865		assert_or_panic(vec[140] == true);
4866		assert_or_panic(vec[141] == false);
4867		assert_or_panic(vec[142] == true);
4868		assert_or_panic(vec[143] == false);
4869		assert_or_panic(vec[144] == false);
4870		assert_or_panic(vec[145] == false);
4871		assert_or_panic(vec[146] == true);
4872		assert_or_panic(vec[147] == false);
4873		assert_or_panic(vec[148] == true);
4874		assert_or_panic(vec[149] == false);
4875		assert_or_panic(vec[150] == false);
4876		assert_or_panic(vec[151] == true);
4877		assert_or_panic(vec[152] == false);
4878		assert_or_panic(vec[153] == true);
4879		assert_or_panic(vec[154] == true);
4880		assert_or_panic(vec[155] == false);
4881		assert_or_panic(vec[156] == true);
4882		assert_or_panic(vec[157] == true);
4883		assert_or_panic(vec[158] == false);
4884		assert_or_panic(vec[159] == true);
4885		assert_or_panic(vec[160] == true);
4886		assert_or_panic(vec[161] == false);
4887		assert_or_panic(vec[162] == false);
4888		assert_or_panic(vec[163] == false);
4889		assert_or_panic(vec[164] == true);
4890		assert_or_panic(vec[165] == false);
4891		assert_or_panic(vec[166] == true);
4892		assert_or_panic(vec[167] == true);
4893		assert_or_panic(vec[168] == true);
4894		assert_or_panic(vec[169] == true);
4895		assert_or_panic(vec[170] == false);
4896		assert_or_panic(vec[171] == true);
4897		assert_or_panic(vec[172] == false);
4898		assert_or_panic(vec[173] == false);
4899		assert_or_panic(vec[174] == true);
4900		assert_or_panic(vec[175] == true);
4901		assert_or_panic(vec[176] == true);
4902		assert_or_panic(vec[177] == false);
4903		assert_or_panic(vec[178] == false);
4904		assert_or_panic(vec[179] == false);
4905		assert_or_panic(vec[180] == true);
4906		assert_or_panic(vec[181] == false);
4907		assert_or_panic(vec[182] == false);
4908		assert_or_panic(vec[183] == true);
4909		assert_or_panic(vec[184] == true);
4910		assert_or_panic(vec[185] == false);
4911		assert_or_panic(vec[186] == true);
4912		assert_or_panic(vec[187] == false);
4913		assert_or_panic(vec[188] == true);
4914		assert_or_panic(vec[189] == true);
4915		assert_or_panic(vec[190] == true);
4916		assert_or_panic(vec[191] == true);
4917		assert_or_panic(vec[192] == true);
4918		assert_or_panic(vec[193] == true);
4919		assert_or_panic(vec[194] == true);
4920		assert_or_panic(vec[195] == false);
4921		assert_or_panic(vec[196] == false);
4922		assert_or_panic(vec[197] == false);
4923		assert_or_panic(vec[198] == false);
4924		assert_or_panic(vec[199] == false);
4925		assert_or_panic(vec[200] == true);
4926		assert_or_panic(vec[201] == false);
4927		assert_or_panic(vec[202] == true);
4928		assert_or_panic(vec[203] == false);
4929		assert_or_panic(vec[204] == true);
4930		assert_or_panic(vec[205] == true);
4931		assert_or_panic(vec[206] == false);
4932		assert_or_panic(vec[207] == false);
4933		assert_or_panic(vec[208] == false);
4934		assert_or_panic(vec[209] == true);
4935		assert_or_panic(vec[210] == true);
4936		assert_or_panic(vec[211] == true);
4937		assert_or_panic(vec[212] == false);
4938		assert_or_panic(vec[213] == false);
4939		assert_or_panic(vec[214] == true);
4940		assert_or_panic(vec[215] == true);
4941		assert_or_panic(vec[216] == true);
4942		assert_or_panic(vec[217] == false);
4943		assert_or_panic(vec[218] == false);
4944		assert_or_panic(vec[219] == true);
4945		assert_or_panic(vec[220] == false);
4946		assert_or_panic(vec[221] == true);
4947		assert_or_panic(vec[222] == true);
4948		assert_or_panic(vec[223] == false);
4949		assert_or_panic(vec[224] == true);
4950		assert_or_panic(vec[225] == false);
4951		assert_or_panic(vec[226] == false);
4952		assert_or_panic(vec[227] == true);
4953		assert_or_panic(vec[228] == false);
4954		assert_or_panic(vec[229] == false);
4955		assert_or_panic(vec[230] == true);
4956		assert_or_panic(vec[231] == true);
4957		assert_or_panic(vec[232] == false);
4958		assert_or_panic(vec[233] == true);
4959		assert_or_panic(vec[234] == true);
4960		assert_or_panic(vec[235] == true);
4961		assert_or_panic(vec[236] == true);
4962		assert_or_panic(vec[237] == true);
4963		assert_or_panic(vec[238] == false);
4964		assert_or_panic(vec[239] == true);
4965		assert_or_panic(vec[240] == false);
4966		assert_or_panic(vec[241] == false);
4967		assert_or_panic(vec[242] == true);
4968		assert_or_panic(vec[243] == false);
4969		assert_or_panic(vec[244] == true);
4970		assert_or_panic(vec[245] == false);
4971		assert_or_panic(vec[246] == true);
4972		assert_or_panic(vec[247] == false);
4973		assert_or_panic(vec[248] == true);
4974		assert_or_panic(vec[249] == true);
4975		assert_or_panic(vec[250] == true);
4976		assert_or_panic(vec[251] == true);
4977		assert_or_panic(vec[252] == true);
4978		assert_or_panic(vec[253] == false);
4979		assert_or_panic(vec[254] == false);
4980		assert_or_panic(vec[255] == false);
4981		assert_or_panic(vec[256] == false);
4982		assert_or_panic(vec[257] == false);
4983		assert_or_panic(vec[258] == false);
4984		assert_or_panic(vec[259] == true);
4985		assert_or_panic(vec[260] == true);
4986		assert_or_panic(vec[261] == true);
4987		assert_or_panic(vec[262] == true);
4988		assert_or_panic(vec[263] == false);
4989		assert_or_panic(vec[264] == false);
4990		assert_or_panic(vec[265] == false);
4991		assert_or_panic(vec[266] == true);
4992		assert_or_panic(vec[267] == false);
4993		assert_or_panic(vec[268] == true);
4994		assert_or_panic(vec[269] == false);
4995		assert_or_panic(vec[270] == true);
4996		assert_or_panic(vec[271] == true);
4997		assert_or_panic(vec[272] == true);
4998		assert_or_panic(vec[273] == true);
4999		assert_or_panic(vec[274] == true);
5000		assert_or_panic(vec[275] == true);
5001		assert_or_panic(vec[276] == false);
5002		assert_or_panic(vec[277] == false);
5003		assert_or_panic(vec[278] == true);
5004		assert_or_panic(vec[279] == true);
5005		assert_or_panic(vec[280] == false);
5006		assert_or_panic(vec[281] == false);
5007		assert_or_panic(vec[282] == false);
5008		assert_or_panic(vec[283] == false);
5009		assert_or_panic(vec[284] == true);
5010		assert_or_panic(vec[285] == true);
5011		assert_or_panic(vec[286] == true);
5012		assert_or_panic(vec[287] == false);
5013		assert_or_panic(vec[288] == false);
5014		assert_or_panic(vec[289] == false);
5015		assert_or_panic(vec[290] == true);
5016		assert_or_panic(vec[291] == false);
5017		assert_or_panic(vec[292] == true);
5018		assert_or_panic(vec[293] == true);
5019		assert_or_panic(vec[294] == false);
5020		assert_or_panic(vec[295] == true);
5021		assert_or_panic(vec[296] == true);
5022		assert_or_panic(vec[297] == true);
5023		assert_or_panic(vec[298] == false);
5024		assert_or_panic(vec[299] == true);
5025		assert_or_panic(vec[300] == true);
5026		assert_or_panic(vec[301] == false);
5027		assert_or_panic(vec[302] == false);
5028		assert_or_panic(vec[303] == true);
5029		assert_or_panic(vec[304] == false);
5030		assert_or_panic(vec[305] == false);
5031		assert_or_panic(vec[306] == true);
5032		assert_or_panic(vec[307] == true);
5033		assert_or_panic(vec[308] == true);
5034		assert_or_panic(vec[309] == true);
5035		assert_or_panic(vec[310] == false);
5036		assert_or_panic(vec[311] == false);
5037		assert_or_panic(vec[312] == false);
5038		assert_or_panic(vec[313] == false);
5039		assert_or_panic(vec[314] == false);
5040		assert_or_panic(vec[315] == true);
5041		assert_or_panic(vec[316] == false);
5042		assert_or_panic(vec[317] == false);
5043		assert_or_panic(vec[318] == true);
5044		assert_or_panic(vec[319] == false);
5045		assert_or_panic(vec[320] == false);
5046		assert_or_panic(vec[321] == true);
5047		assert_or_panic(vec[322] == true);
5048		assert_or_panic(vec[323] == true);
5049		assert_or_panic(vec[324] == true);
5050		assert_or_panic(vec[325] == false);
5051		assert_or_panic(vec[326] == false);
5052		assert_or_panic(vec[327] == false);
5053		assert_or_panic(vec[328] == true);
5054		assert_or_panic(vec[329] == true);
5055		assert_or_panic(vec[330] == false);
5056		assert_or_panic(vec[331] == true);
5057		assert_or_panic(vec[332] == true);
5058		assert_or_panic(vec[333] == false);
5059		assert_or_panic(vec[334] == false);
5060		assert_or_panic(vec[335] == true);
5061		assert_or_panic(vec[336] == true);
5062		assert_or_panic(vec[337] == false);
5063		assert_or_panic(vec[338] == true);
5064		assert_or_panic(vec[339] == true);
5065		assert_or_panic(vec[340] == true);
5066		assert_or_panic(vec[341] == false);
5067		assert_or_panic(vec[342] == false);
5068		assert_or_panic(vec[343] == false);
5069		assert_or_panic(vec[344] == true);
5070		assert_or_panic(vec[345] == true);
5071		assert_or_panic(vec[346] == false);
5072		assert_or_panic(vec[347] == true);
5073		assert_or_panic(vec[348] == false);
5074		assert_or_panic(vec[349] == true);
5075		assert_or_panic(vec[350] == false);
5076		assert_or_panic(vec[351] == false);
5077		assert_or_panic(vec[352] == true);
5078		assert_or_panic(vec[353] == false);
5079		assert_or_panic(vec[354] == true);
5080		assert_or_panic(vec[355] == false);
5081		assert_or_panic(vec[356] == false);
5082		assert_or_panic(vec[357] == false);
5083		assert_or_panic(vec[358] == false);
5084		assert_or_panic(vec[359] == false);
5085		assert_or_panic(vec[360] == true);
5086		assert_or_panic(vec[361] == true);
5087		assert_or_panic(vec[362] == false);
5088		assert_or_panic(vec[363] == false);
5089		assert_or_panic(vec[364] == false);
5090		assert_or_panic(vec[365] == false);
5091		assert_or_panic(vec[366] == true);
5092		assert_or_panic(vec[367] == false);
5093		assert_or_panic(vec[368] == true);
5094		assert_or_panic(vec[369] == false);
5095		assert_or_panic(vec[370] == true);
5096		assert_or_panic(vec[371] == true);
5097		assert_or_panic(vec[372] == false);
5098		assert_or_panic(vec[373] == true);
5099		assert_or_panic(vec[374] == true);
5100		assert_or_panic(vec[375] == true);
5101		assert_or_panic(vec[376] == true);
5102		assert_or_panic(vec[377] == true);
5103		assert_or_panic(vec[378] == false);
5104		assert_or_panic(vec[379] == true);
5105		assert_or_panic(vec[380] == false);
5106		assert_or_panic(vec[381] == true);
5107		assert_or_panic(vec[382] == true);
5108		assert_or_panic(vec[383] == true);
5109		assert_or_panic(vec[384] == true);
5110		assert_or_panic(vec[385] == true);
5111		assert_or_panic(vec[386] == false);
5112		assert_or_panic(vec[387] == true);
5113		assert_or_panic(vec[388] == true);
5114		assert_or_panic(vec[389] == false);
5115		assert_or_panic(vec[390] == true);
5116		assert_or_panic(vec[391] == false);
5117		assert_or_panic(vec[392] == true);
5118		assert_or_panic(vec[393] == false);
5119		assert_or_panic(vec[394] == true);
5120		assert_or_panic(vec[395] == false);
5121		assert_or_panic(vec[396] == true);
5122		assert_or_panic(vec[397] == false);
5123		assert_or_panic(vec[398] == false);
5124		assert_or_panic(vec[399] == true);
5125		assert_or_panic(vec[400] == true);
5126		assert_or_panic(vec[401] == true);
5127		assert_or_panic(vec[402] == true);
5128		assert_or_panic(vec[403] == false);
5129		assert_or_panic(vec[404] == false);
5130		assert_or_panic(vec[405] == true);
5131		assert_or_panic(vec[406] == false);
5132		assert_or_panic(vec[407] == false);
5133		assert_or_panic(vec[408] == false);
5134		assert_or_panic(vec[409] == true);
5135		assert_or_panic(vec[410] == false);
5136		assert_or_panic(vec[411] == true);
5137		assert_or_panic(vec[412] == true);
5138		assert_or_panic(vec[413] == false);
5139		assert_or_panic(vec[414] == true);
5140		assert_or_panic(vec[415] == true);
5141		assert_or_panic(vec[416] == false);
5142		assert_or_panic(vec[417] == true);
5143		assert_or_panic(vec[418] == true);
5144		assert_or_panic(vec[419] == false);
5145		assert_or_panic(vec[420] == false);
5146		assert_or_panic(vec[421] == true);
5147		assert_or_panic(vec[422] == false);
5148		assert_or_panic(vec[423] == false);
5149		assert_or_panic(vec[424] == true);
5150		assert_or_panic(vec[425] == false);
5151		assert_or_panic(vec[426] == true);
5152		assert_or_panic(vec[427] == false);
5153		assert_or_panic(vec[428] == false);
5154		assert_or_panic(vec[429] == true);
5155		assert_or_panic(vec[430] == false);
5156		assert_or_panic(vec[431] == true);
5157		assert_or_panic(vec[432] == true);
5158		assert_or_panic(vec[433] == false);
5159		assert_or_panic(vec[434] == true);
5160		assert_or_panic(vec[435] == false);
5161		assert_or_panic(vec[436] == true);
5162		assert_or_panic(vec[437] == false);
5163		assert_or_panic(vec[438] == true);
5164		assert_or_panic(vec[439] == false);
5165		assert_or_panic(vec[440] == false);
5166		assert_or_panic(vec[441] == true);
5167		assert_or_panic(vec[442] == true);
5168		assert_or_panic(vec[443] == false);
5169		assert_or_panic(vec[444] == true);
5170		assert_or_panic(vec[445] == true);
5171		assert_or_panic(vec[446] == false);
5172		assert_or_panic(vec[447] == true);
5173		assert_or_panic(vec[448] == true);
5174		assert_or_panic(vec[449] == false);
5175		assert_or_panic(vec[450] == false);
5176		assert_or_panic(vec[451] == false);
5177		assert_or_panic(vec[452] == false);
5178		assert_or_panic(vec[453] == false);
5179		assert_or_panic(vec[454] == true);
5180		assert_or_panic(vec[455] == false);
5181		assert_or_panic(vec[456] == false);
5182		assert_or_panic(vec[457] == true);
5183		assert_or_panic(vec[458] == false);
5184		assert_or_panic(vec[459] == true);
5185		assert_or_panic(vec[460] == false);
5186		assert_or_panic(vec[461] == false);
5187		assert_or_panic(vec[462] == false);
5188		assert_or_panic(vec[463] == true);
5189		assert_or_panic(vec[464] == false);
5190		assert_or_panic(vec[465] == true);
5191		assert_or_panic(vec[466] == false);
5192		assert_or_panic(vec[467] == false);
5193		assert_or_panic(vec[468] == false);
5194		assert_or_panic(vec[469] == false);
5195		assert_or_panic(vec[470] == true);
5196		assert_or_panic(vec[471] == true);
5197		assert_or_panic(vec[472] == false);
5198		assert_or_panic(vec[473] == true);
5199		assert_or_panic(vec[474] == true);
5200		assert_or_panic(vec[475] == false);
5201		assert_or_panic(vec[476] == false);
5202		assert_or_panic(vec[477] == true);
5203		assert_or_panic(vec[478] == true);
5204		assert_or_panic(vec[479] == true);
5205		assert_or_panic(vec[480] == false);
5206		assert_or_panic(vec[481] == false);
5207		assert_or_panic(vec[482] == true);
5208		assert_or_panic(vec[483] == false);
5209		assert_or_panic(vec[484] == false);
5210		assert_or_panic(vec[485] == false);
5211		assert_or_panic(vec[486] == true);
5212		assert_or_panic(vec[487] == true);
5213		assert_or_panic(vec[488] == false);
5214		assert_or_panic(vec[489] == false);
5215		assert_or_panic(vec[490] == false);
5216		assert_or_panic(vec[491] == false);
5217		assert_or_panic(vec[492] == false);
5218		assert_or_panic(vec[493] == true);
5219		assert_or_panic(vec[494] == true);
5220		assert_or_panic(vec[495] == true);
5221		assert_or_panic(vec[496] == true);
5222		assert_or_panic(vec[497] == false);
5223		assert_or_panic(vec[498] == false);
5224		assert_or_panic(vec[499] == false);
5225		assert_or_panic(vec[500] == true);
5226		assert_or_panic(vec[501] == false);
5227		assert_or_panic(vec[502] == true);
5228		assert_or_panic(vec[503] == true);
5229		assert_or_panic(vec[504] == true);
5230		assert_or_panic(vec[505] == true);
5231		assert_or_panic(vec[506] == false);
5232		assert_or_panic(vec[507] == false);
5233		assert_or_panic(vec[508] == true);
5234		assert_or_panic(vec[509] == true);
5235		assert_or_panic(vec[510] == false);
5236		assert_or_panic(vec[511] == false);
5237		}
5238		#endif
5239	15507	}
5240	15508
5241	15509	void c_u8(uint8_t x) {
...	...	@@ -5386,51 +15654,6 @@ void c_big_union(union BigUnion x) {
5386	15654	assert_or_panic(x.a.d == 4);
5387	15655	}
5388	15656
5389		void c_small_struct_ints(struct SmallStructInts x) {
5390		assert_or_panic(x.a == 1);
5391		assert_or_panic(x.b == 2);
5392		assert_or_panic(x.c == 3);
5393		assert_or_panic(x.d == 4);
5394
5395		struct SmallStructInts y = zig_ret_small_struct_ints();
5396
5397		assert_or_panic(y.a == 1);
5398		assert_or_panic(y.b == 2);
5399		assert_or_panic(y.c == 3);
5400		assert_or_panic(y.d == 4);
5401		}
5402
5403		struct SmallStructInts c_ret_small_struct_ints() {
5404		struct SmallStructInts s = {
5405		.a = 1,
5406		.b = 2,
5407		.c = 3,
5408		.d = 4,
5409		};
5410		return s;
5411		}
5412
5413		void c_med_struct_ints(struct MedStructInts s) {
5414		assert_or_panic(s.x == 1);
5415		assert_or_panic(s.y == 2);
5416		assert_or_panic(s.z == 3);
5417
5418		struct MedStructInts s2 = zig_ret_med_struct_ints();
5419
5420		assert_or_panic(s2.x == 1);
5421		assert_or_panic(s2.y == 2);
5422		assert_or_panic(s2.z == 3);
5423		}
5424
5425		struct MedStructInts c_ret_med_struct_ints() {
5426		struct MedStructInts s = {
5427		.x = 1,
5428		.y = 2,
5429		.z = 3,
5430		};
5431		return s;
5432		}
5433
5434	15657	void c_med_struct_mixed(struct MedStructMixed x) {
5435	15658	assert_or_panic(x.a == 1234);
5436	15659	assert_or_panic(x.b == 100.0f);
...	...	@@ -5443,7 +15666,7 @@ void c_med_struct_mixed(struct MedStructMixed x) {
5443	15666	assert_or_panic(y.c == 1337.0f);
5444	15667	}
5445	15668
5446		struct MedStructMixed c_ret_med_struct_mixed() {
	15669	struct MedStructMixed c_ret_med_struct_mixed(void) {
5447	15670	struct MedStructMixed s = {
5448	15671	.a = 1234,
5449	15672	.b = 100.0,
...	...	@@ -5469,7 +15692,7 @@ void c_split_struct_mixed(struct SplitStructMixed x) {
5469	15692	assert_or_panic(y.c == 1337.0f);
5470	15693	}
5471	15694
5472		uint8_t c_ret_small_packed_struct() {
	15695	uint8_t c_ret_small_packed_struct(void) {
5473	15696	uint8_t s = 0;
5474	15697	s \|= 0 << 0;
5475	15698	s \|= 1 << 2;
...	...	@@ -5486,7 +15709,7 @@ void c_small_packed_struct(uint8_t x) {
5486	15709	}
5487	15710
5488	15711	#ifndef ZIG_NO_I128
5489		__int128 c_ret_big_packed_struct() {
	15712	__int128 c_ret_big_packed_struct(void) {
5490	15713	__int128 s = 0;
5491	15714	s \|= 1 << 0;
5492	15715	s \|= (__int128)2 << 64;
...	...	@@ -5499,7 +15722,7 @@ void c_big_packed_struct(__int128 x) {
5499	15722	}
5500	15723	#endif
5501	15724
5502		struct SplitStructMixed c_ret_split_struct_mixed() {
	15725	struct SplitStructMixed c_ret_split_struct_mixed(void) {
5503	15726	struct SplitStructMixed s = {
5504	15727	.a = 1234,
5505	15728	.b = 100,
...	...	@@ -5518,74 +15741,31 @@ struct BigStruct c_big_struct_both(struct BigStruct x) {
5518	15741	return y;
5519	15742	}
5520	15743
5521		void c_small_struct_floats(Vector3 vec) {
5522		assert_or_panic(vec.x == 3.0);
5523		assert_or_panic(vec.y == 6.0);
5524		assert_or_panic(vec.z == 12.0);
5525		}
5526
5527		void c_small_struct_floats_extra(Vector3 vec, const char *str) {
5528		assert_or_panic(vec.x == 3.0);
5529		assert_or_panic(vec.y == 6.0);
5530		assert_or_panic(vec.z == 12.0);
5531		assert_or_panic(!strcmp(str, "hello"));
5532		}
5533
5534		void c_big_struct_floats(Vector5 vec) {
5535		assert_or_panic(vec.x == 76.0);
5536		assert_or_panic(vec.y == -1.0);
5537		assert_or_panic(vec.z == -12.0);
5538		assert_or_panic(vec.w == 69);
5539		assert_or_panic(vec.q == 55);
5540		}
5541
5542		void c_multiple_struct_ints(Rect x, Rect y) {
5543		assert_or_panic(x.left == 1);
5544		assert_or_panic(x.right == 21);
5545		assert_or_panic(x.top == 16);
5546		assert_or_panic(x.bottom == 4);
5547		assert_or_panic(y.left == 178);
5548		assert_or_panic(y.right == 189);
5549		assert_or_panic(y.top == 21);
5550		assert_or_panic(y.bottom == 15);
5551		}
5552
5553		void c_multiple_struct_floats(FloatRect x, FloatRect y) {
5554		assert_or_panic(x.left == 1);
5555		assert_or_panic(x.right == 21);
5556		assert_or_panic(x.top == 16);
5557		assert_or_panic(x.bottom == 4);
5558		assert_or_panic(y.left == 178);
5559		assert_or_panic(y.right == 189);
5560		assert_or_panic(y.top == 21);
5561		assert_or_panic(y.bottom == 15);
5562		}
5563
5564		bool c_ret_bool() {
	15744	bool c_ret_bool(void) {
5565	15745	return 1;
5566	15746	}
5567		uint8_t c_ret_u8() {
	15747	uint8_t c_ret_u8(void) {
5568	15748	return 0xff;
5569	15749	}
5570		uint16_t c_ret_u16() {
	15750	uint16_t c_ret_u16(void) {
5571	15751	return 0xffff;
5572	15752	}
5573		uint32_t c_ret_u32() {
	15753	uint32_t c_ret_u32(void) {
5574	15754	return 0xffffffff;
5575	15755	}
5576		uint64_t c_ret_u64() {
	15756	uint64_t c_ret_u64(void) {
5577	15757	return 0xffffffffffffffff;
5578	15758	}
5579		int8_t c_ret_i8() {
	15759	int8_t c_ret_i8(void) {
5580	15760	return -1;
5581	15761	}
5582		int16_t c_ret_i16() {
	15762	int16_t c_ret_i16(void) {
5583	15763	return -1;
5584	15764	}
5585		int32_t c_ret_i32() {
	15765	int32_t c_ret_i32(void) {
5586	15766	return -1;
5587	15767	}
5588		int64_t c_ret_i64() {
	15768	int64_t c_ret_i64(void) {
5589	15769	return -1;
5590	15770	}
5591	15771
...	...	@@ -5600,7 +15780,7 @@ void c_struct_with_array(StructWithArray x) {
5600	15780	assert_or_panic(x.b == 2);
5601	15781	}
5602	15782
5603		StructWithArray c_ret_struct_with_array() {
	15783	StructWithArray c_ret_struct_with_array(void) {
5604	15784	return (StructWithArray){4, {}, 155};
5605	15785	}
5606	15786
...	...	@@ -5622,7 +15802,7 @@ void c_float_array_struct(FloatArrayStruct x) {
5622	15802	assert_or_panic(x.size.height == 8);
5623	15803	}
5624	15804
5625		FloatArrayStruct c_ret_float_array_struct() {
	15805	FloatArrayStruct c_ret_float_array_struct(void) {
5626	15806	FloatArrayStruct x;
5627	15807	x.origin.x = 1;
5628	15808	x.origin.y = 2;
...	...	@@ -5898,7 +16078,6 @@ struct ByRef __attribute__((sysv_abi)) c_explict_sys_v(struct ByRef in) {
5898	16078	}
5899	16079	#endif
5900	16080
5901
5902	16081	struct byval_tail_callsite_attr_Point {
5903	16082	double x;
5904	16083	double y;

test/c_abi/main.zig+15463-4484

...	...	@@ -18,13 +18,12 @@ const have_i128 = builtin.cpu.arch != .x86 and !builtin.cpu.arch.isArm() and
18	18	const have_f128 = builtin.cpu.arch.isWasm() or (builtin.cpu.arch.isX86() and !builtin.os.tag.isDarwin() and builtin.abi != .msvc);
19	19	const have_f80 = builtin.cpu.arch.isX86() and builtin.abi != .msvc;
20	20
21		extern fn run_c_tests() void;
22
23	21	export fn zig_panic() noreturn {
24	22	@panic("zig_panic called from C");
25	23	}
26	24
27		test "C importing Zig ABI Tests" {
	25	extern fn run_c_tests() void;
	26	test run_c_tests {
28	27	run_c_tests();
29	28	}
30	29
...	...	@@ -50,7 +49,7 @@ export fn zig_five_integers(a: i32, b: i32, c: i32, d: i32, e: i32) void {
50	49	expect(e == 90) catch @panic("test failure: zig_five_integers 90");
51	50	}
52	51
53		test "C ABI integers" {
	52	test "integers" {
54	53	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
55	54
56	55	c_u8(0xff);
...	...	@@ -120,13 +119,13 @@ export fn zig_five_floats(a: f32, b: f32, c: f32, d: f32, e: f32) void {
120	119	expect(e == 5.0) catch @panic("test failure: zig_five_floats 5.0");
121	120	}
122	121
123		test "C ABI floats" {
	122	test "floats" {
124	123	c_f32(12.34);
125	124	c_f64(56.78);
126	125	c_five_floats(1.0, 2.0, 3.0, 4.0, 5.0);
127	126	}
128	127
129		test "C ABI long double" {
	128	test "long double" {
130	129	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
131	130
132	131	c_long_double(12.34);
...	...	@@ -145,7 +144,7 @@ export fn zig_longdouble(x: c_longdouble) void {
145	144
146	145	extern fn c_ptr(*anyopaque) void;
147	146
148		test "C ABI pointer" {
	147	test "pointer" {
149	148	c_ptr(@as(*anyopaque, @ptrFromInt(0xdeadbeef)));
150	149	}
151	150
...	...	@@ -155,7 +154,7 @@ export fn zig_ptr(x: *anyopaque) void {
155	154
156	155	extern fn c_bool(bool) void;
157	156
158		test "C ABI bool" {
	157	test "bool" {
159	158	c_bool(true);
160	159	}
161	160
...	...	@@ -190,7 +189,7 @@ const complex_abi_compatible = builtin.cpu.arch != .x86 and !builtin.cpu.arch.is
190	189	builtin.cpu.arch != .s390x and
191	190	!(builtin.cpu.arch.isLoongArch() and builtin.abi.float() == .soft);
192	191
193		test "C ABI complex float" {
	192	test "complex float" {
194	193	if (!complex_abi_compatible) return error.SkipZigTest;
195	194
196	195	const a = ComplexFloat{ .real = 1.25, .imag = 2.6 };
...	...	@@ -201,7 +200,7 @@ test "C ABI complex float" {
201	200	try expect(z.imag == 13.5);
202	201	}
203	202
204		test "C ABI complex float by component" {
	203	test "complex float by component" {
205	204	if (!complex_abi_compatible) return error.SkipZigTest;
206	205
207	206	const a = ComplexFloat{ .real = 1.25, .imag = 2.6 };
...	...	@@ -212,7 +211,7 @@ test "C ABI complex float by component" {
212	211	try expect(z2.imag == 13.5);
213	212	}
214	213
215		test "C ABI complex double" {
	214	test "complex double" {
216	215	if (!complex_abi_compatible) return error.SkipZigTest;
217	216
218	217	const a = ComplexDouble{ .real = 1.25, .imag = 2.6 };
...	...	@@ -223,7 +222,7 @@ test "C ABI complex double" {
223	222	try expect(z.imag == 13.5);
224	223	}
225	224
226		test "C ABI complex double by component" {
	225	test "complex double by component" {
227	226	if (!complex_abi_compatible) return error.SkipZigTest;
228	227
229	228	const a = ComplexDouble{ .real = 1.25, .imag = 2.6 };
...	...	@@ -270,4500 +269,696 @@ export fn zig_cmultd_comp(a_r: f64, a_i: f64, b_r: f64, b_i: f64) ComplexDouble
270	269	return .{ .real = 1.5, .imag = 13.5 };
271	270	}
272	271
273		const Struct_u8 = extern struct {
274		a: u8,
275		};
276
277		export fn zig_ret_struct_u8() Struct_u8 {
278		return .{ .a = 1 };
279		}
	272	comptime {
	273	skip: {
	274	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
	275	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip;
280	276
281		export fn zig_struct_u8(s: Struct_u8, i: usize) void {
282		expect(s.a == 2) catch @panic("test failure");
283		expect(i == 3) catch @panic("test failure");
	277	_ = struct {
	278	export fn zig_ret_vector_2_bool() @Vector(2, bool) {
	279	return .{
	280	false,
	281	false,
	282	};
	283	}
	284	export fn zig_vector_2_bool(vec: @Vector(2, bool)) void {
	285	expect(vec[0] == false) catch @panic("test failure");
	286	expect(vec[1] == true) catch @panic("test failure");
	287	}
	288	};
	289	}
284	290	}
285	291
286		extern fn c_ret_struct_u8() Struct_u8;
287
288		extern fn c_struct_u8(Struct_u8, usize) void;
289
290		test "C ABI struct u8" {
291		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
292		if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
293		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
294		if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
	292	extern fn c_ret_vector_2_bool() @Vector(2, bool);
	293	extern fn c_vector_2_bool(@Vector(2, bool)) void;
	294	extern fn c_test_vector_2_bool() void;
295	295
296		const s = c_ret_struct_u8();
297		try expect(s.a == 4);
298		c_struct_u8(.{ .a = 5 }, 6);
	296	test "@Vector(2, bool)" {
	297	if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest;
	298	if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
	299
	300	const vec = c_ret_vector_2_bool();
	301	try expect(vec[0] == true);
	302	try expect(vec[1] == false);
	303	c_vector_2_bool(.{
	304	true,
	305	true,
	306	});
	307	c_test_vector_2_bool();
299	308	}
300	309
301		const Struct_u16 = extern struct {
302		a: u16,
303		};
304
305		export fn zig_ret_struct_u16() Struct_u16 {
306		return .{ .a = 7 };
307		}
	310	comptime {
	311	skip: {
	312	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
	313	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip;
308	314
309		export fn zig_struct_u16(s: Struct_u16, i: usize) void {
310		expect(s.a == 8) catch @panic("test failure");
311		expect(i == 9) catch @panic("test failure");
	315	_ = struct {
	316	export fn zig_ret_vector_4_bool() @Vector(4, bool) {
	317	return .{
	318	false,
	319	true,
	320	true,
	321	true,
	322	};
	323	}
	324	export fn zig_vector_4_bool(vec: @Vector(4, bool)) void {
	325	expect(vec[0] == false) catch @panic("test failure");
	326	expect(vec[1] == false) catch @panic("test failure");
	327	expect(vec[2] == false) catch @panic("test failure");
	328	expect(vec[3] == false) catch @panic("test failure");
	329	}
	330	};
	331	}
312	332	}
313	333
314		extern fn c_ret_struct_u16() Struct_u16;
315
316		extern fn c_struct_u16(Struct_u16, usize) void;
317
318		test "C ABI struct u16" {
319		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
320		if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
321		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
322		if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
	334	extern fn c_ret_vector_4_bool() @Vector(4, bool);
	335	extern fn c_vector_4_bool(@Vector(4, bool)) void;
	336	extern fn c_test_vector_4_bool() void;
323	337
324		const s = c_ret_struct_u16();
325		try expect(s.a == 10);
326		c_struct_u16(.{ .a = 11 }, 12);
	338	test "@Vector(4, bool)" {
	339	if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest;
	340	if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
	341
	342	const vec = c_ret_vector_4_bool();
	343	try expect(vec[0] == true);
	344	try expect(vec[1] == false);
	345	try expect(vec[2] == true);
	346	try expect(vec[3] == false);
	347	c_vector_4_bool(.{
	348	true,
	349	true,
	350	false,
	351	true,
	352	});
	353	c_test_vector_4_bool();
327	354	}
328	355
329		const Struct_u32 = extern struct {
330		a: u32,
331		};
	356	comptime {
	357	skip: {
	358	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
	359	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip;
332	360
333		export fn zig_ret_struct_u32() Struct_u32 {
334		return .{ .a = 13 };
	361	_ = struct {
	362	export fn zig_ret_vector_8_bool() @Vector(8, bool) {
	363	return .{
	364	false,
	365	false,
	366	false,
	367	false,
	368	true,
	369	false,
	370	false,
	371	false,
	372	};
	373	}
	374	export fn zig_vector_8_bool(vec: @Vector(8, bool)) void {
	375	expect(vec[0] == true) catch @panic("test failure");
	376	expect(vec[1] == true) catch @panic("test failure");
	377	expect(vec[2] == false) catch @panic("test failure");
	378	expect(vec[3] == true) catch @panic("test failure");
	379	expect(vec[4] == false) catch @panic("test failure");
	380	expect(vec[5] == true) catch @panic("test failure");
	381	expect(vec[6] == true) catch @panic("test failure");
	382	expect(vec[7] == false) catch @panic("test failure");
	383	}
	384	};
	385	}
335	386	}
336	387
337		export fn zig_struct_u32(s: Struct_u32, i: usize) void {
338		expect(s.a == 14) catch @panic("test failure");
339		expect(i == 15) catch @panic("test failure");
	388	extern fn c_ret_vector_8_bool() @Vector(8, bool);
	389	extern fn c_vector_8_bool(@Vector(8, bool)) void;
	390	extern fn c_test_vector_8_bool() void;
	391
	392	test "@Vector(8, bool)" {
	393	if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest;
	394	if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
	395
	396	const vec = c_ret_vector_8_bool();
	397	try expect(vec[0] == false);
	398	try expect(vec[1] == true);
	399	try expect(vec[2] == false);
	400	try expect(vec[3] == false);
	401	try expect(vec[4] == true);
	402	try expect(vec[5] == false);
	403	try expect(vec[6] == false);
	404	try expect(vec[7] == true);
	405	c_vector_8_bool(.{
	406	true,
	407	false,
	408	true,
	409	true,
	410	true,
	411	true,
	412	false,
	413	true,
	414	});
	415	c_test_vector_8_bool();
340	416	}
341	417
342		extern fn c_ret_struct_u32() Struct_u32;
	418	comptime {
	419	skip: {
	420	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
	421	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip;
343	422
344		extern fn c_struct_u32(Struct_u32, usize) void;
	423	_ = struct {
	424	export fn zig_ret_vector_16_bool() @Vector(16, bool) {
	425	return .{
	426	false,
	427	true,
	428	false,
	429	false,
	430	false,
	431	true,
	432	false,
	433	false,
	434	true,
	435	false,
	436	false,
	437	false,
	438	false,
	439	true,
	440	false,
	441	false,
	442	};
	443	}
	444	export fn zig_vector_16_bool(vec: @Vector(16, bool)) void {
	445	expect(vec[0] == true) catch @panic("test failure");
	446	expect(vec[1] == false) catch @panic("test failure");
	447	expect(vec[2] == true) catch @panic("test failure");
	448	expect(vec[3] == true) catch @panic("test failure");
	449	expect(vec[4] == true) catch @panic("test failure");
	450	expect(vec[5] == false) catch @panic("test failure");
	451	expect(vec[6] == false) catch @panic("test failure");
	452	expect(vec[7] == false) catch @panic("test failure");
	453	expect(vec[8] == true) catch @panic("test failure");
	454	expect(vec[9] == true) catch @panic("test failure");
	455	expect(vec[10] == true) catch @panic("test failure");
	456	expect(vec[11] == true) catch @panic("test failure");
	457	expect(vec[12] == false) catch @panic("test failure");
	458	expect(vec[13] == false) catch @panic("test failure");
	459	expect(vec[14] == false) catch @panic("test failure");
	460	expect(vec[15] == true) catch @panic("test failure");
	461	}
	462	};
	463	}
	464	}
345	465
346		test "C ABI struct u32" {
347		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
348		if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
349		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
350		if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
	466	extern fn c_ret_vector_16_bool() @Vector(16, bool);
	467	extern fn c_vector_16_bool(@Vector(16, bool)) void;
	468	extern fn c_test_vector_16_bool() void;
351	469
352		const s = c_ret_struct_u32();
353		try expect(s.a == 16);
354		c_struct_u32(.{ .a = 17 }, 18);
	470	test "@Vector(16, bool)" {
	471	if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest;
	472	if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
	473
	474	const vec = c_ret_vector_16_bool();
	475	try expect(vec[0] == true);
	476	try expect(vec[1] == true);
	477	try expect(vec[2] == false);
	478	try expect(vec[3] == false);
	479	try expect(vec[4] == false);
	480	try expect(vec[5] == false);
	481	try expect(vec[6] == true);
	482	try expect(vec[7] == false);
	483	try expect(vec[8] == true);
	484	try expect(vec[9] == false);
	485	try expect(vec[10] == false);
	486	try expect(vec[11] == true);
	487	try expect(vec[12] == true);
	488	try expect(vec[13] == false);
	489	try expect(vec[14] == true);
	490	try expect(vec[15] == true);
	491	c_vector_16_bool(.{
	492	true,
	493	false,
	494	false,
	495	false,
	496	true,
	497	false,
	498	true,
	499	true,
	500	true,
	501	true,
	502	true,
	503	true,
	504	false,
	505	false,
	506	false,
	507	false,
	508	});
	509	c_test_vector_16_bool();
355	510	}
356	511
357		const Struct_u64 = extern struct {
358		a: u64,
359		};
	512	comptime {
	513	skip: {
	514	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
	515	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip;
360	516
361		export fn zig_ret_struct_u64() Struct_u64 {
362		return .{ .a = 19 };
	517	_ = struct {
	518	export fn zig_ret_vector_32_bool() @Vector(32, bool) {
	519	return .{
	520	false,
	521	true,
	522	false,
	523	false,
	524	true,
	525	false,
	526	true,
	527	true,
	528	true,
	529	true,
	530	true,
	531	true,
	532	false,
	533	false,
	534	false,
	535	false,
	536	false,
	537	false,
	538	true,
	539	true,
	540	true,
	541	false,
	542	true,
	543	false,
	544	true,
	545	false,
	546	false,
	547	true,
	548	false,
	549	false,
	550	true,
	551	true,
	552	};
	553	}
	554	export fn zig_vector_32_bool(vec: @Vector(32, bool)) void {
	555	expect(vec[0] == false) catch @panic("test failure");
	556	expect(vec[1] == false) catch @panic("test failure");
	557	expect(vec[2] == false) catch @panic("test failure");
	558	expect(vec[3] == true) catch @panic("test failure");
	559	expect(vec[4] == true) catch @panic("test failure");
	560	expect(vec[5] == false) catch @panic("test failure");
	561	expect(vec[6] == false) catch @panic("test failure");
	562	expect(vec[7] == true) catch @panic("test failure");
	563	expect(vec[8] == false) catch @panic("test failure");
	564	expect(vec[9] == true) catch @panic("test failure");
	565	expect(vec[10] == true) catch @panic("test failure");
	566	expect(vec[11] == true) catch @panic("test failure");
	567	expect(vec[12] == false) catch @panic("test failure");
	568	expect(vec[13] == false) catch @panic("test failure");
	569	expect(vec[14] == true) catch @panic("test failure");
	570	expect(vec[15] == true) catch @panic("test failure");
	571	expect(vec[16] == true) catch @panic("test failure");
	572	expect(vec[17] == true) catch @panic("test failure");
	573	expect(vec[18] == true) catch @panic("test failure");
	574	expect(vec[19] == false) catch @panic("test failure");
	575	expect(vec[20] == true) catch @panic("test failure");
	576	expect(vec[21] == true) catch @panic("test failure");
	577	expect(vec[22] == true) catch @panic("test failure");
	578	expect(vec[23] == false) catch @panic("test failure");
	579	expect(vec[24] == false) catch @panic("test failure");
	580	expect(vec[25] == true) catch @panic("test failure");
	581	expect(vec[26] == true) catch @panic("test failure");
	582	expect(vec[27] == false) catch @panic("test failure");
	583	expect(vec[28] == true) catch @panic("test failure");
	584	expect(vec[29] == true) catch @panic("test failure");
	585	expect(vec[30] == false) catch @panic("test failure");
	586	expect(vec[31] == true) catch @panic("test failure");
	587	}
	588	};
	589	}
363	590	}
364	591
365		export fn zig_struct_u64(s: Struct_u64, i: usize) void {
366		expect(s.a == 20) catch @panic("test failure");
367		expect(i == 21) catch @panic("test failure");
	592	extern fn c_ret_vector_32_bool() @Vector(32, bool);
	593	extern fn c_vector_32_bool(@Vector(32, bool)) void;
	594	extern fn c_test_vector_32_bool() void;
	595
	596	test "@Vector(32, bool)" {
	597	if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest;
	598	if (builtin.zig_backend == .stage2_x86_64 and builtin.os.tag == .windows and builtin.cpu.has(.x86, .avx)) return error.SkipZigTest;
	599
	600	const vec = c_ret_vector_32_bool();
	601	try expect(vec[0] == true);
	602	try expect(vec[1] == false);
	603	try expect(vec[2] == true);
	604	try expect(vec[3] == true);
	605	try expect(vec[4] == true);
	606	try expect(vec[5] == false);
	607	try expect(vec[6] == true);
	608	try expect(vec[7] == false);
	609	try expect(vec[8] == true);
	610	try expect(vec[9] == true);
	611	try expect(vec[10] == true);
	612	try expect(vec[11] == false);
	613	try expect(vec[12] == true);
	614	try expect(vec[13] == true);
	615	try expect(vec[14] == false);
	616	try expect(vec[15] == false);
	617	try expect(vec[16] == true);
	618	try expect(vec[17] == false);
	619	try expect(vec[18] == false);
	620	try expect(vec[19] == false);
	621	try expect(vec[20] == false);
	622	try expect(vec[21] == true);
	623	try expect(vec[22] == true);
	624	try expect(vec[23] == true);
	625	try expect(vec[24] == false);
	626	try expect(vec[25] == true);
	627	try expect(vec[26] == false);
	628	try expect(vec[27] == false);
	629	try expect(vec[28] == true);
	630	try expect(vec[29] == false);
	631	try expect(vec[30] == false);
	632	try expect(vec[31] == false);
	633	c_vector_32_bool(.{
	634	true,
	635	false,
	636	true,
	637	true,
	638	false,
	639	false,
	640	true,
	641	false,
	642	true,
	643	false,
	644	true,
	645	true,
	646	true,
	647	false,
	648	false,
	649	true,
	650	false,
	651	true,
	652	false,
	653	true,
	654	true,
	655	true,
	656	true,
	657	true,
	658	false,
	659	true,
	660	true,
	661	true,
	662	false,
	663	true,
	664	true,
	665	false,
	666	});
	667	c_test_vector_32_bool();
368	668	}
369	669
370		extern fn c_ret_struct_u64() Struct_u64;
	670	comptime {
	671	skip: {
	672	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
	673	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip;
371	674
372		extern fn c_struct_u64(Struct_u64, usize) void;
373
374		test "C ABI struct u64" {
375		if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
376		if (builtin.cpu.arch == .riscv32) return error.SkipZigTest;
377		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
378		if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
379
380		const s = c_ret_struct_u64();
381		try expect(s.a == 22);
382		c_struct_u64(.{ .a = 23 }, 24);
383		}
384
385		const Struct_u64_u64 = extern struct {
386		a: u64,
387		b: u64,
388		};
389
390		export fn zig_ret_struct_u64_u64() Struct_u64_u64 {
391		return .{ .a = 1, .b = 2 };
392		}
393
394		export fn zig_struct_u64_u64_0(s: Struct_u64_u64, i: usize) void {
395		expect(s.a == 3) catch @panic("test failure");
396		expect(s.b == 4) catch @panic("test failure");
397		expect(i == 1) catch @panic("test failure");
398		}
399		export fn zig_struct_u64_u64_1(_: usize, s: Struct_u64_u64, i: usize) void {
400		expect(s.a == 5) catch @panic("test failure");
401		expect(s.b == 6) catch @panic("test failure");
402		expect(i == 2) catch @panic("test failure");
403		}
404		export fn zig_struct_u64_u64_2(_: usize, _: usize, s: Struct_u64_u64, i: usize) void {
405		expect(s.a == 7) catch @panic("test failure");
406		expect(s.b == 8) catch @panic("test failure");
407		expect(i == 3) catch @panic("test failure");
408		}
409		export fn zig_struct_u64_u64_3(_: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
410		expect(s.a == 9) catch @panic("test failure");
411		expect(s.b == 10) catch @panic("test failure");
412		expect(i == 4) catch @panic("test failure");
413		}
414		export fn zig_struct_u64_u64_4(_: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
415		expect(s.a == 11) catch @panic("test failure");
416		expect(s.b == 12) catch @panic("test failure");
417		expect(i == 5) catch @panic("test failure");
418		}
419		export fn zig_struct_u64_u64_5(_: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
420		expect(s.a == 13) catch @panic("test failure");
421		expect(s.b == 14) catch @panic("test failure");
422		expect(i == 6) catch @panic("test failure");
423		}
424		export fn zig_struct_u64_u64_6(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
425		expect(s.a == 15) catch @panic("test failure");
426		expect(s.b == 16) catch @panic("test failure");
427		expect(i == 7) catch @panic("test failure");
428		}
429		export fn zig_struct_u64_u64_7(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
430		expect(s.a == 17) catch @panic("test failure");
431		expect(s.b == 18) catch @panic("test failure");
432		expect(i == 8) catch @panic("test failure");
433		}
434		export fn zig_struct_u64_u64_8(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
435		expect(s.a == 19) catch @panic("test failure");
436		expect(s.b == 20) catch @panic("test failure");
437		expect(i == 9) catch @panic("test failure");
438		}
439
440		extern fn c_ret_struct_u64_u64() Struct_u64_u64;
441
442		extern fn c_struct_u64_u64_0(Struct_u64_u64, usize) void;
443		extern fn c_struct_u64_u64_1(usize, Struct_u64_u64, usize) void;
444		extern fn c_struct_u64_u64_2(usize, usize, Struct_u64_u64, usize) void;
445		extern fn c_struct_u64_u64_3(usize, usize, usize, Struct_u64_u64, usize) void;
446		extern fn c_struct_u64_u64_4(usize, usize, usize, usize, Struct_u64_u64, usize) void;
447		extern fn c_struct_u64_u64_5(usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
448		extern fn c_struct_u64_u64_6(usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
449		extern fn c_struct_u64_u64_7(usize, usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
450		extern fn c_struct_u64_u64_8(usize, usize, usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
451
452		test "C ABI struct u64, u64" {
453		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
454		if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
455		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
456		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
457
458		const s = c_ret_struct_u64_u64();
459		try expect(s.a == 21);
460		try expect(s.b == 22);
461		c_struct_u64_u64_0(.{ .a = 23, .b = 24 }, 1);
462		c_struct_u64_u64_1(0, .{ .a = 25, .b = 26 }, 2);
463		c_struct_u64_u64_2(0, 1, .{ .a = 27, .b = 28 }, 3);
464		c_struct_u64_u64_3(0, 1, 2, .{ .a = 29, .b = 30 }, 4);
465		c_struct_u64_u64_4(0, 1, 2, 3, .{ .a = 31, .b = 32 }, 5);
466		c_struct_u64_u64_5(0, 1, 2, 3, 4, .{ .a = 33, .b = 34 }, 6);
467		c_struct_u64_u64_6(0, 1, 2, 3, 4, 5, .{ .a = 35, .b = 36 }, 7);
468		c_struct_u64_u64_7(0, 1, 2, 3, 4, 5, 6, .{ .a = 37, .b = 38 }, 8);
469		c_struct_u64_u64_8(0, 1, 2, 3, 4, 5, 6, 7, .{ .a = 39, .b = 40 }, 9);
470		}
471
472		const Struct_f32 = extern struct {
473		a: f32,
474		};
475
476		export fn zig_ret_struct_f32() Struct_f32 {
477		return .{ .a = 2.5 };
478		}
479
480		export fn zig_struct_f32(s: Struct_f32) void {
481		expect(s.a == 2.5) catch @panic("test failure");
482		}
483
484		extern fn c_ret_struct_f32() Struct_f32;
485
486		extern fn c_struct_f32(Struct_f32) void;
487
488		test "C ABI struct f32" {
489		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
490		if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
491		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
492		if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
493
494		const s = c_ret_struct_f32();
495		try expect(s.a == 2.5);
496		c_struct_f32(.{ .a = 2.5 });
497		}
498
499		const Struct_f64 = extern struct {
500		a: f64,
501		};
502
503		export fn zig_ret_struct_f64() Struct_f64 {
504		return .{ .a = 2.5 };
505		}
506
507		export fn zig_struct_f64(s: Struct_f64) void {
508		expect(s.a == 2.5) catch @panic("test failure");
	675	_ = struct {
	676	export fn zig_ret_vector_64_bool() @Vector(64, bool) {
	677	return .{
	678	true,
	679	false,
	680	true,
	681	false,
	682	false,
	683	true,
	684	false,
	685	true,
	686	true,
	687	false,
	688	true,
	689	false,
	690	true,
	691	false,
	692	false,
	693	true,
	694	false,
	695	false,
	696	true,
	697	true,
	698	false,
	699	false,
	700	true,
	701	false,
	702	false,
	703	true,
	704	true,
	705	true,
	706	true,
	707	true,
	708	false,
	709	false,
	710	true,
	711	true,
	712	true,
	713	true,
	714	false,
	715	true,
	716	false,
	717	true,
	718	true,
	719	true,
	720	true,
	721	true,
	722	false,
	723	false,
	724	false,
	725	true,
	726	true,
	727	true,
	728	false,
	729	true,
	730	true,
	731	true,
	732	false,
	733	false,
	734	false,
	735	true,
	736	false,
	737	false,
	738	true,
	739	false,
	740	true,
	741	false,
	742	};
	743	}
	744	export fn zig_vector_64_bool(vec: @Vector(64, bool)) void {
	745	expect(vec[0] == true) catch @panic("test failure");
	746	expect(vec[1] == true) catch @panic("test failure");
	747	expect(vec[2] == false) catch @panic("test failure");
	748	expect(vec[3] == true) catch @panic("test failure");
	749	expect(vec[4] == false) catch @panic("test failure");
	750	expect(vec[5] == true) catch @panic("test failure");
	751	expect(vec[6] == false) catch @panic("test failure");
	752	expect(vec[7] == false) catch @panic("test failure");
	753	expect(vec[8] == true) catch @panic("test failure");
	754	expect(vec[9] == true) catch @panic("test failure");
	755	expect(vec[10] == true) catch @panic("test failure");
	756	expect(vec[11] == true) catch @panic("test failure");
	757	expect(vec[12] == true) catch @panic("test failure");
	758	expect(vec[13] == true) catch @panic("test failure");
	759	expect(vec[14] == true) catch @panic("test failure");
	760	expect(vec[15] == false) catch @panic("test failure");
	761	expect(vec[16] == false) catch @panic("test failure");
	762	expect(vec[17] == true) catch @panic("test failure");
	763	expect(vec[18] == true) catch @panic("test failure");
	764	expect(vec[19] == false) catch @panic("test failure");
	765	expect(vec[20] == true) catch @panic("test failure");
	766	expect(vec[21] == true) catch @panic("test failure");
	767	expect(vec[22] == true) catch @panic("test failure");
	768	expect(vec[23] == true) catch @panic("test failure");
	769	expect(vec[24] == false) catch @panic("test failure");
	770	expect(vec[25] == false) catch @panic("test failure");
	771	expect(vec[26] == true) catch @panic("test failure");
	772	expect(vec[27] == false) catch @panic("test failure");
	773	expect(vec[28] == false) catch @panic("test failure");
	774	expect(vec[29] == true) catch @panic("test failure");
	775	expect(vec[30] == false) catch @panic("test failure");
	776	expect(vec[31] == true) catch @panic("test failure");
	777	expect(vec[32] == false) catch @panic("test failure");
	778	expect(vec[33] == true) catch @panic("test failure");
	779	expect(vec[34] == true) catch @panic("test failure");
	780	expect(vec[35] == false) catch @panic("test failure");
	781	expect(vec[36] == true) catch @panic("test failure");
	782	expect(vec[37] == true) catch @panic("test failure");
	783	expect(vec[38] == false) catch @panic("test failure");
	784	expect(vec[39] == false) catch @panic("test failure");
	785	expect(vec[40] == true) catch @panic("test failure");
	786	expect(vec[41] == true) catch @panic("test failure");
	787	expect(vec[42] == true) catch @panic("test failure");
	788	expect(vec[43] == true) catch @panic("test failure");
	789	expect(vec[44] == true) catch @panic("test failure");
	790	expect(vec[45] == false) catch @panic("test failure");
	791	expect(vec[46] == true) catch @panic("test failure");
	792	expect(vec[47] == false) catch @panic("test failure");
	793	expect(vec[48] == false) catch @panic("test failure");
	794	expect(vec[49] == false) catch @panic("test failure");
	795	expect(vec[50] == false) catch @panic("test failure");
	796	expect(vec[51] == false) catch @panic("test failure");
	797	expect(vec[52] == true) catch @panic("test failure");
	798	expect(vec[53] == false) catch @panic("test failure");
	799	expect(vec[54] == false) catch @panic("test failure");
	800	expect(vec[55] == true) catch @panic("test failure");
	801	expect(vec[56] == true) catch @panic("test failure");
	802	expect(vec[57] == false) catch @panic("test failure");
	803	expect(vec[58] == false) catch @panic("test failure");
	804	expect(vec[59] == false) catch @panic("test failure");
	805	expect(vec[60] == true) catch @panic("test failure");
	806	expect(vec[61] == true) catch @panic("test failure");
	807	expect(vec[62] == true) catch @panic("test failure");
	808	expect(vec[63] == true) catch @panic("test failure");
	809	}
	810	};
	811	}
509	812	}
510	813
511		extern fn c_ret_struct_f64() Struct_f64;
512
513		extern fn c_struct_f64(Struct_f64) void;
514
515		test "C ABI struct f64" {
516		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
517		if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
518		if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
519		if (builtin.cpu.arch == .riscv32) return error.SkipZigTest;
520		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
521		if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
522
523		const s = c_ret_struct_f64();
524		try expect(s.a == 2.5);
525		c_struct_f64(.{ .a = 2.5 });
526		}
	814	extern fn c_ret_vector_64_bool() @Vector(64, bool);
	815	extern fn c_vector_64_bool(@Vector(64, bool)) void;
	816	extern fn c_test_vector_64_bool() void;
527	817
528		const Struct_f32a8 = extern struct {
529		a: f32 align(8),
530		};
	818	test "@Vector(64, bool)" {
	819	if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest;
531	820
532		export fn zig_ret_struct_f32a8() Struct_f32a8 {
533		return .{ .a = 1.25 };
	821	const vec = c_ret_vector_64_bool();
	822	try expect(vec[0] == false);
	823	try expect(vec[1] == true);
	824	try expect(vec[2] == false);
	825	try expect(vec[3] == true);
	826	try expect(vec[4] == true);
	827	try expect(vec[5] == true);
	828	try expect(vec[6] == false);
	829	try expect(vec[7] == true);
	830	try expect(vec[8] == true);
	831	try expect(vec[9] == true);
	832	try expect(vec[10] == true);
	833	try expect(vec[11] == true);
	834	try expect(vec[12] == true);
	835	try expect(vec[13] == false);
	836	try expect(vec[14] == true);
	837	try expect(vec[15] == true);
	838	try expect(vec[16] == true);
	839	try expect(vec[17] == false);
	840	try expect(vec[18] == false);
	841	try expect(vec[19] == false);
	842	try expect(vec[20] == true);
	843	try expect(vec[21] == true);
	844	try expect(vec[22] == false);
	845	try expect(vec[23] == true);
	846	try expect(vec[24] == false);
	847	try expect(vec[25] == true);
	848	try expect(vec[26] == false);
	849	try expect(vec[27] == true);
	850	try expect(vec[28] == false);
	851	try expect(vec[29] == true);
	852	try expect(vec[30] == false);
	853	try expect(vec[31] == true);
	854	try expect(vec[32] == false);
	855	try expect(vec[33] == false);
	856	try expect(vec[34] == true);
	857	try expect(vec[35] == true);
	858	try expect(vec[36] == false);
	859	try expect(vec[37] == false);
	860	try expect(vec[38] == false);
	861	try expect(vec[39] == true);
	862	try expect(vec[40] == true);
	863	try expect(vec[41] == true);
	864	try expect(vec[42] == true);
	865	try expect(vec[43] == false);
	866	try expect(vec[44] == false);
	867	try expect(vec[45] == false);
	868	try expect(vec[46] == true);
	869	try expect(vec[47] == true);
	870	try expect(vec[48] == false);
	871	try expect(vec[49] == false);
	872	try expect(vec[50] == true);
	873	try expect(vec[51] == false);
	874	try expect(vec[52] == false);
	875	try expect(vec[53] == false);
	876	try expect(vec[54] == false);
	877	try expect(vec[55] == true);
	878	try expect(vec[56] == false);
	879	try expect(vec[57] == false);
	880	try expect(vec[58] == false);
	881	try expect(vec[59] == true);
	882	try expect(vec[60] == true);
	883	try expect(vec[61] == true);
	884	try expect(vec[62] == true);
	885	try expect(vec[63] == true);
	886	c_vector_64_bool(.{
	887	true,
	888	true,
	889	true,
	890	false,
	891	true,
	892	false,
	893	false,
	894	false,
	895	true,
	896	false,
	897	false,
	898	false,
	899	false,
	900	true,
	901	true,
	902	true,
	903	true,
	904	false,
	905	false,
	906	true,
	907	false,
	908	true,
	909	false,
	910	true,
	911	true,
	912	true,
	913	true,
	914	true,
	915	true,
	916	true,
	917	false,
	918	false,
	919	true,
	920	true,
	921	false,
	922	true,
	923	false,
	924	false,
	925	true,
	926	true,
	927	true,
	928	false,
	929	false,
	930	true,
	931	true,
	932	false,
	933	true,
	934	false,
	935	true,
	936	false,
	937	false,
	938	true,
	939	false,
	940	true,
	941	true,
	942	true,
	943	true,
	944	true,
	945	false,
	946	false,
	947	true,
	948	false,
	949	true,
	950	false,
	951	});
	952	c_test_vector_64_bool();
534	953	}
535	954
536		export fn zig_struct_f32a8(s: Struct_f32a8, f: f32) void {
537		expect(s.a == 2.75) catch @panic("test failure");
538		expect(f == 3.5) catch @panic("test failure");
539		}
	955	comptime {
	956	skip: {
	957	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
	958	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip;
540	959
541		extern fn c_ret_struct_f32a8() Struct_f32a8;
542
543		extern fn c_struct_f32a8(Struct_f32a8, f32) void;
544
545		test "C ABI struct f32 align(8)" {
546		if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
547		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
548		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
549		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
550		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
551		if (builtin.cpu.arch == .riscv32) return error.SkipZigTest;
552		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
553		if (builtin.cpu.arch == .x86) return error.SkipZigTest;
554
555		const s = c_ret_struct_f32a8();
556		try expect(s.a == 4.125);
557		c_struct_f32a8(.{ .a = 5.375 }, 6.5);
558		}
559
560		const Struct_f32a8_f32a8 = extern struct {
561		a: f32 align(8),
562		b: f32 align(8),
563		};
564
565		export fn zig_ret_struct_f32a8_f32a8() Struct_f32a8_f32a8 {
566		return .{ .a = 1.25, .b = 2.75 };
567		}
568
569		export fn zig_struct_f32a8_f32a8(s: Struct_f32a8_f32a8, f: f32) void {
570		expect(s.a == 3.125) catch @panic("test failure");
571		expect(s.b == 4.375) catch @panic("test failure");
572		expect(f == 5.5) catch @panic("test failure");
573		}
574
575		extern fn c_ret_struct_f32a8_f32a8() Struct_f32a8_f32a8;
576
577		extern fn c_struct_f32a8_f32a8(Struct_f32a8_f32a8, f32) void;
578
579		test "C ABI struct f32 align(8), f32 align(8)" {
580		if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
581		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
582		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
583		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
584		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
585		if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
586		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
587		if (builtin.cpu.arch == .x86) return error.SkipZigTest;
588
589		const s = c_ret_struct_f32a8_f32a8();
590		try expect(s.a == 6.625);
591		try expect(s.b == 7.875);
592		c_struct_f32a8_f32a8(.{ .a = 8.0625, .b = 9.1875 }, 10.5);
593		}
594
595		const Struct_f32f32_f32 = extern struct {
596		a: extern struct { b: f32, c: f32 },
597		d: f32,
598		};
599
600		export fn zig_ret_struct_f32f32_f32() Struct_f32f32_f32 {
601		return .{ .a = .{ .b = 1.0, .c = 2.0 }, .d = 3.0 };
602		}
603
604		export fn zig_struct_f32f32_f32(s: Struct_f32f32_f32) void {
605		expect(s.a.b == 1.0) catch @panic("test failure");
606		expect(s.a.c == 2.0) catch @panic("test failure");
607		expect(s.d == 3.0) catch @panic("test failure");
608		}
609
610		extern fn c_ret_struct_f32f32_f32() Struct_f32f32_f32;
611
612		extern fn c_struct_f32f32_f32(Struct_f32f32_f32) void;
613
614		test "C ABI struct {f32, f32}, f32" {
615		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
616		if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
617		if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
618		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
619		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
620		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
621
622		const s = c_ret_struct_f32f32_f32();
623		try expect(s.a.b == 1.0);
624		try expect(s.a.c == 2.0);
625		try expect(s.d == 3.0);
626		c_struct_f32f32_f32(.{ .a = .{ .b = 1.0, .c = 2.0 }, .d = 3.0 });
627		}
628
629		const Struct_f32_f32f32 = extern struct {
630		a: f32,
631		b: extern struct { c: f32, d: f32 },
632		};
633
634		export fn zig_ret_struct_f32_f32f32() Struct_f32_f32f32 {
635		return .{ .a = 1.0, .b = .{ .c = 2.0, .d = 3.0 } };
636		}
637
638		export fn zig_struct_f32_f32f32(s: Struct_f32_f32f32) void {
639		expect(s.a == 1.0) catch @panic("test failure");
640		expect(s.b.c == 2.0) catch @panic("test failure");
641		expect(s.b.d == 3.0) catch @panic("test failure");
642		}
643
644		extern fn c_ret_struct_f32_f32f32() Struct_f32_f32f32;
645
646		extern fn c_struct_f32_f32f32(Struct_f32_f32f32) void;
647
648		test "C ABI struct f32 {f32,f32}" {
649		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
650		if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
651		if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
652		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
653		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
654		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
655
656		const s = c_ret_struct_f32_f32f32();
657		try expect(s.a == 1.0);
658		try expect(s.b.c == 2.0);
659		try expect(s.b.d == 3.0);
660		c_struct_f32_f32f32(.{ .a = 1.0, .b = .{ .c = 2.0, .d = 3.0 } });
661		}
662
663		const Struct_u32_Union_u32_u32u32 = extern struct {
664		a: u32,
665		b: extern union {
666		c: extern struct {
667		d: u32,
668		e: u32,
669		},
670		},
671		};
672
673		export fn zig_ret_struct_u32_union_u32_u32u32() Struct_u32_Union_u32_u32u32 {
674		return .{ .a = 1, .b = .{ .c = .{ .d = 2, .e = 3 } } };
675		}
676
677		export fn zig_struct_u32_union_u32_u32u32(s: Struct_u32_Union_u32_u32u32) void {
678		expect(s.a == 1) catch @panic("test failure");
679		expect(s.b.c.d == 2) catch @panic("test failure");
680		expect(s.b.c.e == 3) catch @panic("test failure");
681		}
682
683		extern fn c_ret_struct_u32_union_u32_u32u32() Struct_u32_Union_u32_u32u32;
684
685		extern fn c_struct_u32_union_u32_u32u32(Struct_u32_Union_u32_u32u32) void;
686
687		test "C ABI struct{u32,union{u32,struct{u32,u32}}}" {
688		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
689		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
690		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
691		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
692		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
693
694		const s = c_ret_struct_u32_union_u32_u32u32();
695		try expect(s.a == 1);
696		try expect(s.b.c.d == 2);
697		try expect(s.b.c.e == 3);
698		c_struct_u32_union_u32_u32u32(.{ .a = 1, .b = .{ .c = .{ .d = 2, .e = 3 } } });
699		}
700
701		const Struct_i32_i32 = extern struct {
702		a: i32,
703		b: i32,
704		};
705		extern fn c_mut_struct_i32_i32(Struct_i32_i32) Struct_i32_i32;
706		extern fn c_struct_i32_i32(Struct_i32_i32) void;
707
708		test "C ABI struct i32 i32" {
709		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
710		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
711		if (builtin.cpu.arch == .riscv32) return error.SkipZigTest;
712		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
713		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
714		if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
715
716		const s: Struct_i32_i32 = .{
717		.a = 1,
718		.b = 2,
719		};
720		const mut_res = c_mut_struct_i32_i32(s);
721		try expect(s.a == 1);
722		try expect(s.b == 2);
723		try expect(mut_res.a == 101);
724		try expect(mut_res.b == 252);
725		c_struct_i32_i32(s);
726		}
727
728		export fn zig_struct_i32_i32(s: Struct_i32_i32) void {
729		expect(s.a == 1) catch @panic("test failure: zig_struct_i32_i32 1");
730		expect(s.b == 2) catch @panic("test failure: zig_struct_i32_i32 2");
731		}
732
733		const BigStruct = extern struct {
734		a: u64,
735		b: u64,
736		c: u64,
737		d: u64,
738		e: u8,
739		};
740		extern fn c_big_struct(BigStruct) void;
741
742		test "C ABI big struct" {
743		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
744		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
745		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
746		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
747		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
748
749		const s = BigStruct{
750		.a = 1,
751		.b = 2,
752		.c = 3,
753		.d = 4,
754		.e = 5,
755		};
756		c_big_struct(s);
757		}
758
759		export fn zig_big_struct(x: BigStruct) void {
760		expect(x.a == 1) catch @panic("test failure: zig_big_struct 1");
761		expect(x.b == 2) catch @panic("test failure: zig_big_struct 2");
762		expect(x.c == 3) catch @panic("test failure: zig_big_struct 3");
763		expect(x.d == 4) catch @panic("test failure: zig_big_struct 4");
764		expect(x.e == 5) catch @panic("test failure: zig_big_struct 5");
765		}
766
767		const BigUnion = extern union {
768		a: BigStruct,
769		};
770		extern fn c_big_union(BigUnion) void;
771
772		test "C ABI big union" {
773		if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
774		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
775		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
776		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
777
778		const x = BigUnion{
779		.a = BigStruct{
780		.a = 1,
781		.b = 2,
782		.c = 3,
783		.d = 4,
784		.e = 5,
785		},
786		};
787		c_big_union(x);
788		}
789
790		export fn zig_big_union(x: BigUnion) void {
791		expect(x.a.a == 1) catch @panic("test failure: zig_big_union a");
792		expect(x.a.b == 2) catch @panic("test failure: zig_big_union b");
793		expect(x.a.c == 3) catch @panic("test failure: zig_big_union c");
794		expect(x.a.d == 4) catch @panic("test failure: zig_big_union d");
795		expect(x.a.e == 5) catch @panic("test failure: zig_big_union e");
796		}
797
798		const MedStructMixed = extern struct {
799		a: u32,
800		b: f32,
801		c: f32,
802		d: u32 = 0,
803		};
804		extern fn c_med_struct_mixed(MedStructMixed) void;
805		extern fn c_ret_med_struct_mixed() MedStructMixed;
806
807		test "C ABI medium struct of ints and floats" {
808		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
809		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
810		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
811		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
812		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
813
814		const s = MedStructMixed{
815		.a = 1234,
816		.b = 100.0,
817		.c = 1337.0,
818		};
819		c_med_struct_mixed(s);
820		const s2 = c_ret_med_struct_mixed();
821		try expect(s2.a == 1234);
822		try expect(s2.b == 100.0);
823		try expect(s2.c == 1337.0);
824		}
825
826		export fn zig_med_struct_mixed(x: MedStructMixed) void {
827		expect(x.a == 1234) catch @panic("test failure");
828		expect(x.b == 100.0) catch @panic("test failure");
829		expect(x.c == 1337.0) catch @panic("test failure");
830		}
831
832		const SmallStructInts = extern struct {
833		a: u8,
834		b: u8,
835		c: u8,
836		d: u8,
837		};
838		extern fn c_small_struct_ints(SmallStructInts) void;
839		extern fn c_ret_small_struct_ints() SmallStructInts;
840
841		test "C ABI small struct of ints" {
842		if (builtin.cpu.arch == .x86) return error.SkipZigTest;
843		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
844		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
845		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
846		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
847		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
848
849		const s = SmallStructInts{
850		.a = 1,
851		.b = 2,
852		.c = 3,
853		.d = 4,
854		};
855		c_small_struct_ints(s);
856		const s2 = c_ret_small_struct_ints();
857		try expect(s2.a == 1);
858		try expect(s2.b == 2);
859		try expect(s2.c == 3);
860		try expect(s2.d == 4);
861		}
862
863		export fn zig_small_struct_ints(x: SmallStructInts) void {
864		expect(x.a == 1) catch @panic("test failure");
865		expect(x.b == 2) catch @panic("test failure");
866		expect(x.c == 3) catch @panic("test failure");
867		expect(x.d == 4) catch @panic("test failure");
868		}
869
870		const MedStructInts = extern struct {
871		x: i32,
872		y: i32,
873		z: i32,
874		};
875		extern fn c_med_struct_ints(MedStructInts) void;
876		extern fn c_ret_med_struct_ints() MedStructInts;
877
878		test "C ABI medium struct of ints" {
879		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
880		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
881		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
882		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
883		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
884
885		const s = MedStructInts{
886		.x = 1,
887		.y = 2,
888		.z = 3,
889		};
890		c_med_struct_ints(s);
891		const s2 = c_ret_med_struct_ints();
892		try expect(s2.x == 1);
893		try expect(s2.y == 2);
894		try expect(s2.z == 3);
895		}
896
897		export fn zig_med_struct_ints(s: MedStructInts) void {
898		expect(s.x == 1) catch @panic("test failure");
899		expect(s.y == 2) catch @panic("test failure");
900		expect(s.z == 3) catch @panic("test failure");
901		}
902
903		const SmallPackedStruct = packed struct(u8) {
904		a: u2,
905		b: u2,
906		c: u2,
907		d: u2,
908		};
909		extern fn c_small_packed_struct(SmallPackedStruct) void;
910		extern fn c_ret_small_packed_struct() SmallPackedStruct;
911
912		export fn zig_small_packed_struct(x: SmallPackedStruct) void {
913		expect(x.a == 0) catch @panic("test failure");
914		expect(x.b == 1) catch @panic("test failure");
915		expect(x.c == 2) catch @panic("test failure");
916		expect(x.d == 3) catch @panic("test failure");
917		}
918
919		test "C ABI small packed struct" {
920		const s = SmallPackedStruct{ .a = 0, .b = 1, .c = 2, .d = 3 };
921		c_small_packed_struct(s);
922		const s2 = c_ret_small_packed_struct();
923		try expect(s2.a == 0);
924		try expect(s2.b == 1);
925		try expect(s2.c == 2);
926		try expect(s2.d == 3);
927		}
928
929		const BigPackedStruct = packed struct(u128) {
930		a: u64,
931		b: u64,
932		};
933		extern fn c_big_packed_struct(BigPackedStruct) void;
934		extern fn c_ret_big_packed_struct() BigPackedStruct;
935
936		export fn zig_big_packed_struct(x: BigPackedStruct) void {
937		expect(x.a == 1) catch @panic("test failure");
938		expect(x.b == 2) catch @panic("test failure");
939		}
940
941		test "C ABI big packed struct" {
942		if (!have_i128) return error.SkipZigTest;
943
944		const s = BigPackedStruct{ .a = 1, .b = 2 };
945		c_big_packed_struct(s);
946		const s2 = c_ret_big_packed_struct();
947		try expect(s2.a == 1);
948		try expect(s2.b == 2);
949		}
950
951		const SplitStructInt = extern struct {
952		a: u64,
953		b: u8,
954		c: u32,
955		};
956		extern fn c_split_struct_ints(SplitStructInt) void;
957
958		test "C ABI split struct of ints" {
959		if (builtin.cpu.arch == .x86) return error.SkipZigTest;
960		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
961		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
962		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
963		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
964		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
965
966		const s = SplitStructInt{
967		.a = 1234,
968		.b = 100,
969		.c = 1337,
970		};
971		c_split_struct_ints(s);
972		}
973
974		export fn zig_split_struct_ints(x: SplitStructInt) void {
975		expect(x.a == 1234) catch @panic("test failure");
976		expect(x.b == 100) catch @panic("test failure");
977		expect(x.c == 1337) catch @panic("test failure");
978		}
979
980		const SplitStructMixed = extern struct {
981		a: u64,
982		b: u8,
983		c: f32,
984		};
985		extern fn c_split_struct_mixed(SplitStructMixed) void;
986		extern fn c_ret_split_struct_mixed() SplitStructMixed;
987
988		test "C ABI split struct of ints and floats" {
989		if (builtin.cpu.arch == .x86) return error.SkipZigTest;
990		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
991		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
992		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
993		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
994		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
995
996		const s = SplitStructMixed{
997		.a = 1234,
998		.b = 100,
999		.c = 1337.0,
1000		};
1001		c_split_struct_mixed(s);
1002		const s2 = c_ret_split_struct_mixed();
1003		try expect(s2.a == 1234);
1004		try expect(s2.b == 100);
1005		try expect(s2.c == 1337.0);
1006		}
1007
1008		export fn zig_split_struct_mixed(x: SplitStructMixed) void {
1009		expect(x.a == 1234) catch @panic("test failure");
1010		expect(x.b == 100) catch @panic("test failure");
1011		expect(x.c == 1337.0) catch @panic("test failure");
1012		}
1013
1014		extern fn c_big_struct_both(BigStruct) BigStruct;
1015
1016		extern fn c_multiple_struct_ints(Rect, Rect) void;
1017		extern fn c_multiple_struct_floats(FloatRect, FloatRect) void;
1018
1019		test "C ABI sret and byval together" {
1020		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
1021		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
1022		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1023		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
1024		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1025
1026		const s = BigStruct{
1027		.a = 1,
1028		.b = 2,
1029		.c = 3,
1030		.d = 4,
1031		.e = 5,
1032		};
1033		const y = c_big_struct_both(s);
1034		try expect(y.a == 10);
1035		try expect(y.b == 11);
1036		try expect(y.c == 12);
1037		try expect(y.d == 13);
1038		try expect(y.e == 14);
1039		}
1040
1041		export fn zig_big_struct_both(x: BigStruct) BigStruct {
1042		expect(x.a == 30) catch @panic("test failure");
1043		expect(x.b == 31) catch @panic("test failure");
1044		expect(x.c == 32) catch @panic("test failure");
1045		expect(x.d == 33) catch @panic("test failure");
1046		expect(x.e == 34) catch @panic("test failure");
1047		const s = BigStruct{
1048		.a = 20,
1049		.b = 21,
1050		.c = 22,
1051		.d = 23,
1052		.e = 24,
1053		};
1054		return s;
1055		}
1056
1057		const Vector3 = extern struct {
1058		x: f32,
1059		y: f32,
1060		z: f32,
1061		};
1062		extern fn c_small_struct_floats(Vector3) void;
1063		extern fn c_small_struct_floats_extra(Vector3, ?[*]const u8) void;
1064
1065		const Vector5 = extern struct {
1066		x: f32,
1067		y: f32,
1068		z: f32,
1069		w: f32,
1070		q: f32,
1071		};
1072		extern fn c_big_struct_floats(Vector5) void;
1073
1074		test "C ABI structs of floats as parameter" {
1075		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
1076		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
1077		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1078		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
1079		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1080
1081		const v3 = Vector3{
1082		.x = 3.0,
1083		.y = 6.0,
1084		.z = 12.0,
1085		};
1086		c_small_struct_floats(v3);
1087		c_small_struct_floats_extra(v3, "hello");
1088
1089		const v5 = Vector5{
1090		.x = 76.0,
1091		.y = -1.0,
1092		.z = -12.0,
1093		.w = 69.0,
1094		.q = 55,
1095		};
1096		c_big_struct_floats(v5);
1097		}
1098
1099		const Rect = extern struct {
1100		left: u32,
1101		right: u32,
1102		top: u32,
1103		bottom: u32,
1104		};
1105
1106		export fn zig_multiple_struct_ints(x: Rect, y: Rect) void {
1107		expect(x.left == 1) catch @panic("test failure");
1108		expect(x.right == 21) catch @panic("test failure");
1109		expect(x.top == 16) catch @panic("test failure");
1110		expect(x.bottom == 4) catch @panic("test failure");
1111		expect(y.left == 178) catch @panic("test failure");
1112		expect(y.right == 189) catch @panic("test failure");
1113		expect(y.top == 21) catch @panic("test failure");
1114		expect(y.bottom == 15) catch @panic("test failure");
1115		}
1116
1117		test "C ABI structs of ints as multiple parameters" {
1118		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
1119		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1120		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
1121		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
1122		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1123
1124		const r1 = Rect{
1125		.left = 1,
1126		.right = 21,
1127		.top = 16,
1128		.bottom = 4,
1129		};
1130		const r2 = Rect{
1131		.left = 178,
1132		.right = 189,
1133		.top = 21,
1134		.bottom = 15,
1135		};
1136		c_multiple_struct_ints(r1, r2);
1137		}
1138
1139		const FloatRect = extern struct {
1140		left: f32,
1141		right: f32,
1142		top: f32,
1143		bottom: f32,
1144		};
1145
1146		export fn zig_multiple_struct_floats(x: FloatRect, y: FloatRect) void {
1147		expect(x.left == 1) catch @panic("test failure");
1148		expect(x.right == 21) catch @panic("test failure");
1149		expect(x.top == 16) catch @panic("test failure");
1150		expect(x.bottom == 4) catch @panic("test failure");
1151		expect(y.left == 178) catch @panic("test failure");
1152		expect(y.right == 189) catch @panic("test failure");
1153		expect(y.top == 21) catch @panic("test failure");
1154		expect(y.bottom == 15) catch @panic("test failure");
1155		}
1156
1157		test "C ABI structs of floats as multiple parameters" {
1158		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
1159		if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
1160		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1161		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
1162		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1163
1164		const r1 = FloatRect{
1165		.left = 1,
1166		.right = 21,
1167		.top = 16,
1168		.bottom = 4,
1169		};
1170		const r2 = FloatRect{
1171		.left = 178,
1172		.right = 189,
1173		.top = 21,
1174		.bottom = 15,
1175		};
1176		c_multiple_struct_floats(r1, r2);
1177		}
1178
1179		export fn zig_ret_bool() bool {
1180		return true;
1181		}
1182		export fn zig_ret_u8() u8 {
1183		return 0xff;
1184		}
1185		export fn zig_ret_u16() u16 {
1186		return 0xffff;
1187		}
1188		export fn zig_ret_u32() u32 {
1189		return 0xffffffff;
1190		}
1191		export fn zig_ret_u64() u64 {
1192		return 0xffffffffffffffff;
1193		}
1194		export fn zig_ret_i8() i8 {
1195		return -1;
1196		}
1197		export fn zig_ret_i16() i16 {
1198		return -1;
1199		}
1200		export fn zig_ret_i32() i32 {
1201		return -1;
1202		}
1203		export fn zig_ret_i64() i64 {
1204		return -1;
1205		}
1206
1207		export fn zig_ret_small_struct_ints() SmallStructInts {
1208		return .{
1209		.a = 1,
1210		.b = 2,
1211		.c = 3,
1212		.d = 4,
1213		};
1214		}
1215
1216		export fn zig_ret_med_struct_ints() MedStructInts {
1217		return .{
1218		.x = 1,
1219		.y = 2,
1220		.z = 3,
1221		};
1222		}
1223
1224		export fn zig_ret_med_struct_mixed() MedStructMixed {
1225		return .{
1226		.a = 1234,
1227		.b = 100.0,
1228		.c = 1337.0,
1229		};
1230		}
1231
1232		export fn zig_ret_split_struct_mixed() SplitStructMixed {
1233		return .{
1234		.a = 1234,
1235		.b = 100,
1236		.c = 1337.0,
1237		};
1238		}
1239
1240		extern fn c_ret_bool() bool;
1241		extern fn c_ret_u8() u8;
1242		extern fn c_ret_u16() u16;
1243		extern fn c_ret_u32() u32;
1244		extern fn c_ret_u64() u64;
1245		extern fn c_ret_i8() i8;
1246		extern fn c_ret_i16() i16;
1247		extern fn c_ret_i32() i32;
1248		extern fn c_ret_i64() i64;
1249
1250		test "C ABI integer return types" {
1251		try expect(c_ret_bool() == true);
1252
1253		try expect(c_ret_u8() == 0xff);
1254		try expect(c_ret_u16() == 0xffff);
1255		try expect(c_ret_u32() == 0xffffffff);
1256		try expect(c_ret_u64() == 0xffffffffffffffff);
1257
1258		try expect(c_ret_i8() == -1);
1259		try expect(c_ret_i16() == -1);
1260		try expect(c_ret_i32() == -1);
1261		try expect(c_ret_i64() == -1);
1262		}
1263
1264		const StructWithArray = extern struct {
1265		a: i32,
1266		padding: [4]u8,
1267		b: i64,
1268		};
1269		extern fn c_struct_with_array(StructWithArray) void;
1270		extern fn c_ret_struct_with_array() StructWithArray;
1271
1272		test "Struct with array as padding." {
1273		if (builtin.cpu.arch == .x86) return error.SkipZigTest;
1274		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
1275		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
1276		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1277		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
1278		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1279
1280		c_struct_with_array(.{ .a = 1, .padding = undefined, .b = 2 });
1281
1282		const x = c_ret_struct_with_array();
1283		try expect(x.a == 4);
1284		try expect(x.b == 155);
1285		}
1286
1287		const FloatArrayStruct = extern struct {
1288		origin: extern struct {
1289		x: f64,
1290		y: f64,
1291		},
1292		size: extern struct {
1293		width: f64,
1294		height: f64,
1295		},
1296		};
1297
1298		extern fn c_float_array_struct(FloatArrayStruct) void;
1299		extern fn c_ret_float_array_struct() FloatArrayStruct;
1300
1301		test "Float array like struct" {
1302		if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
1303		if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
1304		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1305		if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
1306		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1307
1308		c_float_array_struct(.{
1309		.origin = .{
1310		.x = 5,
1311		.y = 6,
1312		},
1313		.size = .{
1314		.width = 7,
1315		.height = 8,
1316		},
1317		});
1318
1319		const x = c_ret_float_array_struct();
1320		try expect(x.origin.x == 1);
1321		try expect(x.origin.y == 2);
1322		try expect(x.size.width == 3);
1323		try expect(x.size.height == 4);
1324		}
1325
1326		const SmallVec = @Vector(2, u32);
1327
1328		extern fn c_small_vec(SmallVec) void;
1329		extern fn c_ret_small_vec() SmallVec;
1330
1331		test "small simd vector" {
1332		if (builtin.cpu.arch == .x86) return error.SkipZigTest;
1333		if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
1334		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1335		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1336
1337		c_small_vec(.{ 1, 2 });
1338
1339		const x = c_ret_small_vec();
1340		try expect(x[0] == 3);
1341		try expect(x[1] == 4);
1342		}
1343
1344		const MediumVec = @Vector(4, usize);
1345
1346		extern fn c_medium_vec(MediumVec) void;
1347		extern fn c_ret_medium_vec() MediumVec;
1348
1349		test "medium simd vector" {
1350		if (builtin.zig_backend == .stage2_x86_64 and !comptime builtin.cpu.has(.x86, .avx)) return error.SkipZigTest;
1351		if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
1352		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1353		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1354
1355		c_medium_vec(.{ 1, 2, 3, 4 });
1356
1357		const x = c_ret_medium_vec();
1358		try expect(x[0] == 5);
1359		try expect(x[1] == 6);
1360		try expect(x[2] == 7);
1361		try expect(x[3] == 8);
1362		}
1363
1364		const BigVec = @Vector(8, usize);
1365
1366		extern fn c_big_vec(BigVec) void;
1367		extern fn c_ret_big_vec() BigVec;
1368
1369		test "big simd vector" {
1370		if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest;
1371
1372		if (builtin.cpu.arch.isMIPS64() and builtin.mode != .Debug) return error.SkipZigTest;
1373		if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
1374		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1375		if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag.isDarwin() and builtin.mode != .Debug) return error.SkipZigTest;
1376		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1377
1378		c_big_vec(.{ 1, 2, 3, 4, 5, 6, 7, 8 });
1379
1380		const x = c_ret_big_vec();
1381		try expect(x[0] == 9);
1382		try expect(x[1] == 10);
1383		try expect(x[2] == 11);
1384		try expect(x[3] == 12);
1385		try expect(x[4] == 13);
1386		try expect(x[5] == 14);
1387		try expect(x[6] == 15);
1388		try expect(x[7] == 16);
1389		}
1390
1391		const Vector2Float = @Vector(2, f32);
1392		const Vector4Float = @Vector(4, f32);
1393
1394		extern fn c_vector_2_float(Vector2Float) void;
1395		extern fn c_vector_4_float(Vector4Float) void;
1396
1397		extern fn c_ret_vector_2_float() Vector2Float;
1398		extern fn c_ret_vector_4_float() Vector4Float;
1399
1400		test "float simd vectors" {
1401		if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
1402		if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
1403		if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
1404
1405		{
1406		c_vector_2_float(.{ 1.0, 2.0 });
1407		const vec = c_ret_vector_2_float();
1408		try expect(vec[0] == 1.0);
1409		try expect(vec[1] == 2.0);
1410		}
1411		{
1412		c_vector_4_float(.{ 1.0, 2.0, 3.0, 4.0 });
1413		const vec = c_ret_vector_4_float();
1414		try expect(vec[0] == 1.0);
1415		try expect(vec[1] == 2.0);
1416		try expect(vec[2] == 3.0);
1417		try expect(vec[3] == 4.0);
1418		}
1419		}
1420
1421		const Vector2Bool = @Vector(2, bool);
1422		const Vector4Bool = @Vector(4, bool);
1423		const Vector8Bool = @Vector(8, bool);
1424		const Vector16Bool = @Vector(16, bool);
1425		const Vector32Bool = @Vector(32, bool);
1426		const Vector64Bool = @Vector(64, bool);
1427		const Vector128Bool = @Vector(128, bool);
1428		const Vector256Bool = @Vector(256, bool);
1429		const Vector512Bool = @Vector(512, bool);
1430
1431		extern fn c_vector_2_bool(Vector2Bool) void;
1432		extern fn c_vector_4_bool(Vector4Bool) void;
1433		extern fn c_vector_8_bool(Vector8Bool) void;
1434		extern fn c_vector_16_bool(Vector16Bool) void;
1435		extern fn c_vector_32_bool(Vector32Bool) void;
1436		extern fn c_vector_64_bool(Vector64Bool) void;
1437		extern fn c_vector_128_bool(Vector128Bool) void;
1438		extern fn c_vector_256_bool(Vector256Bool) void;
1439		extern fn c_vector_512_bool(Vector512Bool) void;
1440
1441		extern fn c_ret_vector_2_bool() Vector2Bool;
1442		extern fn c_ret_vector_4_bool() Vector4Bool;
1443		extern fn c_ret_vector_8_bool() Vector8Bool;
1444		extern fn c_ret_vector_16_bool() Vector16Bool;
1445		extern fn c_ret_vector_32_bool() Vector32Bool;
1446		extern fn c_ret_vector_64_bool() Vector64Bool;
1447		extern fn c_ret_vector_128_bool() Vector128Bool;
1448		extern fn c_ret_vector_256_bool() Vector256Bool;
1449		extern fn c_ret_vector_512_bool() Vector512Bool;
1450
1451		test "bool simd vector" {
1452		if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest;
1453
1454		{
1455		c_vector_2_bool(.{
1456		true,
1457		true,
1458		});
1459
1460		const vec = c_ret_vector_2_bool();
1461		try expect(vec[0] == true);
1462		try expect(vec[1] == false);
1463		}
1464		{
1465		c_vector_4_bool(.{
1466		true,
1467		true,
1468		false,
1469		true,
1470		});
1471
1472		const vec = c_ret_vector_4_bool();
1473		try expect(vec[0] == true);
1474		try expect(vec[1] == false);
1475		try expect(vec[2] == true);
1476		try expect(vec[3] == false);
1477		}
1478		{
1479		c_vector_8_bool(.{
1480		true,
1481		false,
1482		true,
1483		true,
1484		true,
1485		true,
1486		false,
1487		true,
1488		});
1489
1490		const vec = c_ret_vector_8_bool();
1491		try expect(vec[0] == false);
1492		try expect(vec[1] == true);
1493		try expect(vec[2] == false);
1494		try expect(vec[3] == false);
1495		try expect(vec[4] == true);
1496		try expect(vec[5] == false);
1497		try expect(vec[6] == false);
1498		try expect(vec[7] == true);
1499		}
1500		{
1501		c_vector_16_bool(.{
1502		true,
1503		false,
1504		false,
1505		false,
1506		true,
1507		false,
1508		true,
1509		true,
1510		true,
1511		true,
1512		true,
1513		true,
1514		false,
1515		false,
1516		false,
1517		false,
1518		});
1519
1520		const vec = c_ret_vector_16_bool();
1521		try expect(vec[0] == true);
1522		try expect(vec[1] == true);
1523		try expect(vec[2] == false);
1524		try expect(vec[3] == false);
1525		try expect(vec[4] == false);
1526		try expect(vec[5] == false);
1527		try expect(vec[6] == true);
1528		try expect(vec[7] == false);
1529		try expect(vec[8] == true);
1530		try expect(vec[9] == false);
1531		try expect(vec[10] == false);
1532		try expect(vec[11] == true);
1533		try expect(vec[12] == true);
1534		try expect(vec[13] == false);
1535		try expect(vec[14] == true);
1536		try expect(vec[15] == true);
1537		}
1538		{
1539		c_vector_32_bool(.{
1540		true,
1541		false,
1542		true,
1543		true,
1544		false,
1545		false,
1546		true,
1547		false,
1548		true,
1549		false,
1550		true,
1551		true,
1552		true,
1553		false,
1554		false,
1555		true,
1556		false,
1557		true,
1558		false,
1559		true,
1560		true,
1561		true,
1562		true,
1563		true,
1564		false,
1565		true,
1566		true,
1567		true,
1568		false,
1569		true,
1570		true,
1571		false,
1572		});
1573
1574		const vec = c_ret_vector_32_bool();
1575		try expect(vec[0] == true);
1576		try expect(vec[1] == false);
1577		try expect(vec[2] == true);
1578		try expect(vec[3] == true);
1579		try expect(vec[4] == true);
1580		try expect(vec[5] == false);
1581		try expect(vec[6] == true);
1582		try expect(vec[7] == false);
1583		try expect(vec[8] == true);
1584		try expect(vec[9] == true);
1585		try expect(vec[10] == true);
1586		try expect(vec[11] == false);
1587		try expect(vec[12] == true);
1588		try expect(vec[13] == true);
1589		try expect(vec[14] == false);
1590		try expect(vec[15] == false);
1591		try expect(vec[16] == true);
1592		try expect(vec[17] == false);
1593		try expect(vec[18] == false);
1594		try expect(vec[19] == false);
1595		try expect(vec[20] == false);
1596		try expect(vec[21] == true);
1597		try expect(vec[22] == true);
1598		try expect(vec[23] == true);
1599		try expect(vec[24] == false);
1600		try expect(vec[25] == true);
1601		try expect(vec[26] == false);
1602		try expect(vec[27] == false);
1603		try expect(vec[28] == true);
1604		try expect(vec[29] == false);
1605		try expect(vec[30] == false);
1606		try expect(vec[31] == false);
1607		}
1608		{
1609		c_vector_64_bool(.{
1610		true,
1611		true,
1612		true,
1613		false,
1614		true,
1615		false,
1616		false,
1617		false,
1618		true,
1619		false,
1620		false,
1621		false,
1622		false,
1623		true,
1624		true,
1625		true,
1626		true,
1627		false,
1628		false,
1629		true,
1630		false,
1631		true,
1632		false,
1633		true,
1634		true,
1635		true,
1636		true,
1637		true,
1638		true,
1639		true,
1640		false,
1641		false,
1642		true,
1643		true,
1644		false,
1645		true,
1646		false,
1647		false,
1648		true,
1649		true,
1650		true,
1651		false,
1652		false,
1653		true,
1654		true,
1655		false,
1656		true,
1657		false,
1658		true,
1659		false,
1660		false,
1661		true,
1662		false,
1663		true,
1664		true,
1665		true,
1666		true,
1667		true,
1668		false,
1669		false,
1670		true,
1671		false,
1672		true,
1673		false,
1674		});
1675
1676		const vec = c_ret_vector_64_bool();
1677		try expect(vec[0] == false);
1678		try expect(vec[1] == true);
1679		try expect(vec[2] == false);
1680		try expect(vec[3] == true);
1681		try expect(vec[4] == true);
1682		try expect(vec[5] == true);
1683		try expect(vec[6] == false);
1684		try expect(vec[7] == true);
1685		try expect(vec[8] == true);
1686		try expect(vec[9] == true);
1687		try expect(vec[10] == true);
1688		try expect(vec[11] == true);
1689		try expect(vec[12] == true);
1690		try expect(vec[13] == false);
1691		try expect(vec[14] == true);
1692		try expect(vec[15] == true);
1693		try expect(vec[16] == true);
1694		try expect(vec[17] == false);
1695		try expect(vec[18] == false);
1696		try expect(vec[19] == false);
1697		try expect(vec[20] == true);
1698		try expect(vec[21] == true);
1699		try expect(vec[22] == false);
1700		try expect(vec[23] == true);
1701		try expect(vec[24] == false);
1702		try expect(vec[25] == true);
1703		try expect(vec[26] == false);
1704		try expect(vec[27] == true);
1705		try expect(vec[28] == false);
1706		try expect(vec[29] == true);
1707		try expect(vec[30] == false);
1708		try expect(vec[31] == true);
1709		try expect(vec[32] == false);
1710		try expect(vec[33] == false);
1711		try expect(vec[34] == true);
1712		try expect(vec[35] == true);
1713		try expect(vec[36] == false);
1714		try expect(vec[37] == false);
1715		try expect(vec[38] == false);
1716		try expect(vec[39] == true);
1717		try expect(vec[40] == true);
1718		try expect(vec[41] == true);
1719		try expect(vec[42] == true);
1720		try expect(vec[43] == false);
1721		try expect(vec[44] == false);
1722		try expect(vec[45] == false);
1723		try expect(vec[46] == true);
1724		try expect(vec[47] == true);
1725		try expect(vec[48] == false);
1726		try expect(vec[49] == false);
1727		try expect(vec[50] == true);
1728		try expect(vec[51] == false);
1729		try expect(vec[52] == false);
1730		try expect(vec[53] == false);
1731		try expect(vec[54] == false);
1732		try expect(vec[55] == true);
1733		try expect(vec[56] == false);
1734		try expect(vec[57] == false);
1735		try expect(vec[58] == false);
1736		try expect(vec[59] == true);
1737		try expect(vec[60] == true);
1738		try expect(vec[61] == true);
1739		try expect(vec[62] == true);
1740		try expect(vec[63] == true);
1741		}
1742		{
1743		c_vector_128_bool(.{
1744		false,
1745		false,
1746		false,
1747		false,
1748		false,
1749		true,
1750		true,
1751		false,
1752		true,
1753		true,
1754		false,
1755		true,
1756		true,
1757		false,
1758		true,
1759		true,
1760		true,
1761		false,
1762		false,
1763		false,
1764		false,
1765		true,
1766		true,
1767		false,
1768		false,
1769		false,
1770		true,
1771		true,
1772		false,
1773		true,
1774		false,
1775		false,
1776		true,
1777		false,
1778		false,
1779		true,
1780		true,
1781		true,
1782		true,
1783		true,
1784		false,
1785		true,
1786		true,
1787		true,
1788		false,
1789		false,
1790		false,
1791		false,
1792		true,
1793		true,
1794		false,
1795		true,
1796		true,
1797		true,
1798		true,
1799		true,
1800		false,
1801		true,
1802		true,
1803		false,
1804		true,
1805		false,
1806		false,
1807		true,
1808		true,
1809		false,
1810		true,
1811		true,
1812		false,
1813		true,
1814		false,
1815		false,
1816		true,
1817		true,
1818		false,
1819		true,
1820		true,
1821		true,
1822		false,
1823		true,
1824		false,
1825		false,
1826		false,
1827		false,
1828		true,
1829		false,
1830		false,
1831		false,
1832		true,
1833		true,
1834		false,
1835		false,
1836		true,
1837		true,
1838		true,
1839		true,
1840		false,
1841		false,
1842		false,
1843		false,
1844		false,
1845		true,
1846		false,
1847		false,
1848		false,
1849		false,
1850		true,
1851		true,
1852		true,
1853		true,
1854		true,
1855		false,
1856		false,
1857		true,
1858		false,
1859		true,
1860		false,
1861		false,
1862		true,
1863		false,
1864		true,
1865		false,
1866		true,
1867		true,
1868		true,
1869		true,
1870		true,
1871		true,
1872		});
1873
1874		const vec = c_ret_vector_128_bool();
1875		try expect(vec[0] == false);
1876		try expect(vec[1] == true);
1877		try expect(vec[2] == true);
1878		try expect(vec[3] == false);
1879		try expect(vec[4] == true);
1880		try expect(vec[5] == false);
1881		try expect(vec[6] == false);
1882		try expect(vec[7] == true);
1883		try expect(vec[8] == true);
1884		try expect(vec[9] == false);
1885		try expect(vec[10] == true);
1886		try expect(vec[11] == false);
1887		try expect(vec[12] == false);
1888		try expect(vec[13] == false);
1889		try expect(vec[14] == true);
1890		try expect(vec[15] == false);
1891		try expect(vec[16] == true);
1892		try expect(vec[17] == false);
1893		try expect(vec[18] == false);
1894		try expect(vec[19] == true);
1895		try expect(vec[20] == false);
1896		try expect(vec[21] == true);
1897		try expect(vec[22] == false);
1898		try expect(vec[23] == false);
1899		try expect(vec[24] == false);
1900		try expect(vec[25] == true);
1901		try expect(vec[26] == true);
1902		try expect(vec[27] == true);
1903		try expect(vec[28] == false);
1904		try expect(vec[29] == false);
1905		try expect(vec[30] == false);
1906		try expect(vec[31] == false);
1907		try expect(vec[32] == true);
1908		try expect(vec[33] == true);
1909		try expect(vec[34] == true);
1910		try expect(vec[35] == false);
1911		try expect(vec[36] == true);
1912		try expect(vec[37] == true);
1913		try expect(vec[38] == false);
1914		try expect(vec[39] == false);
1915		try expect(vec[40] == false);
1916		try expect(vec[41] == false);
1917		try expect(vec[42] == true);
1918		try expect(vec[43] == true);
1919		try expect(vec[44] == true);
1920		try expect(vec[45] == false);
1921		try expect(vec[46] == false);
1922		try expect(vec[47] == false);
1923		try expect(vec[48] == false);
1924		try expect(vec[49] == true);
1925		try expect(vec[50] == false);
1926		try expect(vec[51] == false);
1927		try expect(vec[52] == true);
1928		try expect(vec[53] == false);
1929		try expect(vec[54] == false);
1930		try expect(vec[55] == false);
1931		try expect(vec[56] == false);
1932		try expect(vec[57] == false);
1933		try expect(vec[58] == true);
1934		try expect(vec[59] == true);
1935		try expect(vec[60] == true);
1936		try expect(vec[61] == false);
1937		try expect(vec[62] == true);
1938		try expect(vec[63] == true);
1939		try expect(vec[64] == false);
1940		try expect(vec[65] == false);
1941		try expect(vec[66] == false);
1942		try expect(vec[67] == false);
1943		try expect(vec[68] == false);
1944		try expect(vec[69] == false);
1945		try expect(vec[70] == false);
1946		try expect(vec[71] == false);
1947		try expect(vec[72] == true);
1948		try expect(vec[73] == true);
1949		try expect(vec[74] == true);
1950		try expect(vec[75] == true);
1951		try expect(vec[76] == true);
1952		try expect(vec[77] == false);
1953		try expect(vec[78] == false);
1954		try expect(vec[79] == false);
1955		try expect(vec[80] == false);
1956		try expect(vec[81] == false);
1957		try expect(vec[82] == false);
1958		try expect(vec[83] == true);
1959		try expect(vec[84] == false);
1960		try expect(vec[85] == true);
1961		try expect(vec[86] == false);
1962		try expect(vec[87] == true);
1963		try expect(vec[88] == false);
1964		try expect(vec[89] == true);
1965		try expect(vec[90] == false);
1966		try expect(vec[91] == true);
1967		try expect(vec[92] == true);
1968		try expect(vec[93] == true);
1969		try expect(vec[94] == true);
1970		try expect(vec[95] == false);
1971		try expect(vec[96] == false);
1972		try expect(vec[97] == true);
1973		try expect(vec[98] == false);
1974		try expect(vec[99] == false);
1975		try expect(vec[100] == true);
1976		try expect(vec[101] == true);
1977		try expect(vec[102] == true);
1978		try expect(vec[103] == true);
1979		try expect(vec[104] == false);
1980		try expect(vec[105] == true);
1981		try expect(vec[106] == true);
1982		try expect(vec[107] == true);
1983		try expect(vec[108] == false);
1984		try expect(vec[109] == false);
1985		try expect(vec[110] == true);
1986		try expect(vec[111] == false);
1987		try expect(vec[112] == false);
1988		try expect(vec[113] == true);
1989		try expect(vec[114] == true);
1990		try expect(vec[115] == false);
1991		try expect(vec[116] == true);
1992		try expect(vec[117] == false);
1993		try expect(vec[118] == true);
1994		try expect(vec[119] == true);
1995		try expect(vec[120] == true);
1996		try expect(vec[121] == true);
1997		try expect(vec[122] == true);
1998		try expect(vec[123] == false);
1999		try expect(vec[124] == false);
2000		try expect(vec[125] == true);
2001		try expect(vec[126] == false);
2002		try expect(vec[127] == true);
2003		}
2004
2005		{
2006		if (!builtin.target.cpu.arch.isWasm()) c_vector_256_bool(.{
2007		false,
2008		true,
2009		true,
2010		false,
2011		false,
2012		true,
2013		true,
2014		true,
2015		false,
2016		true,
2017		true,
2018		true,
2019		false,
2020		true,
2021		false,
2022		true,
2023		false,
2024		false,
2025		true,
2026		true,
2027		false,
2028		true,
2029		false,
2030		false,
2031		false,
2032		true,
2033		true,
2034		false,
2035		false,
2036		true,
2037		true,
2038		false,
2039		true,
2040		false,
2041		false,
2042		true,
2043		false,
2044		true,
2045		false,
2046		true,
2047		true,
2048		true,
2049		true,
2050		false,
2051		false,
2052		true,
2053		false,
2054		false,
2055		false,
2056		false,
2057		false,
2058		false,
2059		true,
2060		true,
2061		true,
2062		true,
2063		true,
2064		true,
2065		false,
2066		true,
2067		true,
2068		false,
2069		false,
2070		true,
2071		false,
2072		false,
2073		false,
2074		false,
2075		false,
2076		false,
2077		true,
2078		true,
2079		true,
2080		false,
2081		false,
2082		false,
2083		true,
2084		false,
2085		true,
2086		true,
2087		false,
2088		false,
2089		true,
2090		true,
2091		false,
2092		true,
2093		true,
2094		true,
2095		true,
2096		true,
2097		true,
2098		true,
2099		false,
2100		true,
2101		true,
2102		false,
2103		false,
2104		true,
2105		true,
2106		false,
2107		true,
2108		false,
2109		false,
2110		true,
2111		false,
2112		true,
2113		true,
2114		true,
2115		true,
2116		true,
2117		false,
2118		false,
2119		false,
2120		false,
2121		true,
2122		true,
2123		false,
2124		true,
2125		false,
2126		false,
2127		true,
2128		false,
2129		false,
2130		true,
2131		false,
2132		true,
2133		true,
2134		true,
2135		true,
2136		false,
2137		true,
2138		true,
2139		false,
2140		false,
2141		true,
2142		false,
2143		false,
2144		true,
2145		false,
2146		true,
2147		false,
2148		true,
2149		true,
2150		true,
2151		true,
2152		false,
2153		true,
2154		false,
2155		false,
2156		false,
2157		true,
2158		true,
2159		true,
2160		true,
2161		true,
2162		false,
2163		true,
2164		false,
2165		false,
2166		false,
2167		true,
2168		true,
2169		false,
2170		true,
2171		true,
2172		false,
2173		false,
2174		false,
2175		false,
2176		true,
2177		false,
2178		true,
2179		false,
2180		false,
2181		false,
2182		false,
2183		true,
2184		true,
2185		true,
2186		false,
2187		true,
2188		false,
2189		true,
2190		true,
2191		false,
2192		false,
2193		true,
2194		false,
2195		false,
2196		false,
2197		false,
2198		true,
2199		true,
2200		true,
2201		true,
2202		true,
2203		true,
2204		true,
2205		false,
2206		true,
2207		false,
2208		false,
2209		true,
2210		false,
2211		true,
2212		true,
2213		true,
2214		false,
2215		false,
2216		true,
2217		true,
2218		true,
2219		false,
2220		true,
2221		true,
2222		true,
2223		true,
2224		true,
2225		false,
2226		false,
2227		false,
2228		false,
2229		false,
2230		true,
2231		true,
2232		false,
2233		true,
2234		false,
2235		false,
2236		true,
2237		false,
2238		true,
2239		false,
2240		false,
2241		false,
2242		true,
2243		false,
2244		false,
2245		false,
2246		true,
2247		true,
2248		true,
2249		true,
2250		true,
2251		true,
2252		false,
2253		false,
2254		true,
2255		false,
2256		true,
2257		true,
2258		false,
2259		true,
2260		true,
2261		true,
2262		false,
2263		});
2264
2265		const vec = c_ret_vector_256_bool();
2266		try expect(vec[0] == true);
2267		try expect(vec[1] == false);
2268		try expect(vec[2] == true);
2269		try expect(vec[3] == true);
2270		try expect(vec[4] == false);
2271		try expect(vec[5] == false);
2272		try expect(vec[6] == false);
2273		try expect(vec[7] == false);
2274		try expect(vec[8] == false);
2275		try expect(vec[9] == true);
2276		try expect(vec[10] == false);
2277		try expect(vec[11] == true);
2278		try expect(vec[12] == false);
2279		try expect(vec[13] == true);
2280		try expect(vec[14] == false);
2281		try expect(vec[15] == false);
2282		try expect(vec[16] == true);
2283		try expect(vec[17] == true);
2284		try expect(vec[18] == true);
2285		try expect(vec[19] == false);
2286		try expect(vec[20] == false);
2287		try expect(vec[21] == false);
2288		try expect(vec[22] == true);
2289		try expect(vec[23] == false);
2290		try expect(vec[24] == true);
2291		try expect(vec[25] == false);
2292		try expect(vec[26] == false);
2293		try expect(vec[27] == true);
2294		try expect(vec[28] == true);
2295		try expect(vec[29] == true);
2296		try expect(vec[30] == false);
2297		try expect(vec[31] == false);
2298		try expect(vec[32] == true);
2299		try expect(vec[33] == true);
2300		try expect(vec[34] == true);
2301		try expect(vec[35] == false);
2302		try expect(vec[36] == true);
2303		try expect(vec[37] == true);
2304		try expect(vec[38] == true);
2305		try expect(vec[39] == false);
2306		try expect(vec[40] == true);
2307		try expect(vec[41] == false);
2308		try expect(vec[42] == true);
2309		try expect(vec[43] == true);
2310		try expect(vec[44] == false);
2311		try expect(vec[45] == true);
2312		try expect(vec[46] == false);
2313		try expect(vec[47] == true);
2314		try expect(vec[48] == true);
2315		try expect(vec[49] == false);
2316		try expect(vec[50] == false);
2317		try expect(vec[51] == true);
2318		try expect(vec[52] == true);
2319		try expect(vec[53] == false);
2320		try expect(vec[54] == false);
2321		try expect(vec[55] == true);
2322		try expect(vec[56] == false);
2323		try expect(vec[57] == true);
2324		try expect(vec[58] == true);
2325		try expect(vec[59] == true);
2326		try expect(vec[60] == false);
2327		try expect(vec[61] == true);
2328		try expect(vec[62] == true);
2329		try expect(vec[63] == false);
2330		try expect(vec[64] == true);
2331		try expect(vec[65] == true);
2332		try expect(vec[66] == false);
2333		try expect(vec[67] == true);
2334		try expect(vec[68] == false);
2335		try expect(vec[69] == true);
2336		try expect(vec[70] == true);
2337		try expect(vec[71] == true);
2338		try expect(vec[72] == false);
2339		try expect(vec[73] == true);
2340		try expect(vec[74] == true);
2341		try expect(vec[75] == false);
2342		try expect(vec[76] == true);
2343		try expect(vec[77] == true);
2344		try expect(vec[78] == true);
2345		try expect(vec[79] == true);
2346		try expect(vec[80] == false);
2347		try expect(vec[81] == true);
2348		try expect(vec[82] == false);
2349		try expect(vec[83] == true);
2350		try expect(vec[84] == true);
2351		try expect(vec[85] == true);
2352		try expect(vec[86] == false);
2353		try expect(vec[87] == true);
2354		try expect(vec[88] == false);
2355		try expect(vec[89] == true);
2356		try expect(vec[90] == false);
2357		try expect(vec[91] == false);
2358		try expect(vec[92] == true);
2359		try expect(vec[93] == false);
2360		try expect(vec[94] == false);
2361		try expect(vec[95] == false);
2362		try expect(vec[96] == true);
2363		try expect(vec[97] == true);
2364		try expect(vec[98] == false);
2365		try expect(vec[99] == false);
2366		try expect(vec[100] == false);
2367		try expect(vec[101] == true);
2368		try expect(vec[102] == true);
2369		try expect(vec[103] == true);
2370		try expect(vec[104] == false);
2371		try expect(vec[105] == false);
2372		try expect(vec[106] == false);
2373		try expect(vec[107] == true);
2374		try expect(vec[108] == false);
2375		try expect(vec[109] == true);
2376		try expect(vec[110] == true);
2377		try expect(vec[111] == true);
2378		try expect(vec[112] == true);
2379		try expect(vec[113] == true);
2380		try expect(vec[114] == true);
2381		try expect(vec[115] == true);
2382		try expect(vec[116] == true);
2383		try expect(vec[117] == false);
2384		try expect(vec[118] == true);
2385		try expect(vec[119] == false);
2386		try expect(vec[120] == true);
2387		try expect(vec[121] == false);
2388		try expect(vec[122] == false);
2389		try expect(vec[123] == true);
2390		try expect(vec[124] == true);
2391		try expect(vec[125] == false);
2392		try expect(vec[126] == true);
2393		try expect(vec[127] == false);
2394		try expect(vec[128] == false);
2395		try expect(vec[129] == false);
2396		try expect(vec[130] == false);
2397		try expect(vec[131] == true);
2398		try expect(vec[132] == false);
2399		try expect(vec[133] == false);
2400		try expect(vec[134] == true);
2401		try expect(vec[135] == false);
2402		try expect(vec[136] == false);
2403		try expect(vec[137] == false);
2404		try expect(vec[138] == false);
2405		try expect(vec[139] == false);
2406		try expect(vec[140] == false);
2407		try expect(vec[141] == true);
2408		try expect(vec[142] == false);
2409		try expect(vec[143] == true);
2410		try expect(vec[144] == false);
2411		try expect(vec[145] == true);
2412		try expect(vec[146] == true);
2413		try expect(vec[147] == true);
2414		try expect(vec[148] == false);
2415		try expect(vec[149] == true);
2416		try expect(vec[150] == true);
2417		try expect(vec[151] == false);
2418		try expect(vec[152] == true);
2419		try expect(vec[153] == true);
2420		try expect(vec[154] == false);
2421		try expect(vec[155] == true);
2422		try expect(vec[156] == true);
2423		try expect(vec[157] == true);
2424		try expect(vec[158] == true);
2425		try expect(vec[159] == true);
2426		try expect(vec[160] == true);
2427		try expect(vec[161] == true);
2428		try expect(vec[162] == false);
2429		try expect(vec[163] == false);
2430		try expect(vec[164] == false);
2431		try expect(vec[165] == true);
2432		try expect(vec[166] == false);
2433		try expect(vec[167] == false);
2434		try expect(vec[168] == true);
2435		try expect(vec[169] == false);
2436		try expect(vec[170] == true);
2437		try expect(vec[171] == true);
2438		try expect(vec[172] == true);
2439		try expect(vec[173] == false);
2440		try expect(vec[174] == false);
2441		try expect(vec[175] == true);
2442		try expect(vec[176] == true);
2443		try expect(vec[177] == true);
2444		try expect(vec[178] == true);
2445		try expect(vec[179] == false);
2446		try expect(vec[180] == true);
2447		try expect(vec[181] == true);
2448		try expect(vec[182] == false);
2449		try expect(vec[183] == true);
2450		try expect(vec[184] == false);
2451		try expect(vec[185] == false);
2452		try expect(vec[186] == false);
2453		try expect(vec[187] == true);
2454		try expect(vec[188] == true);
2455		try expect(vec[189] == true);
2456		try expect(vec[190] == true);
2457		try expect(vec[191] == true);
2458		try expect(vec[192] == true);
2459		try expect(vec[193] == true);
2460		try expect(vec[194] == true);
2461		try expect(vec[195] == false);
2462		try expect(vec[196] == false);
2463		try expect(vec[197] == true);
2464		try expect(vec[198] == false);
2465		try expect(vec[199] == false);
2466		try expect(vec[200] == false);
2467		try expect(vec[201] == true);
2468		try expect(vec[202] == true);
2469		try expect(vec[203] == true);
2470		try expect(vec[204] == true);
2471		try expect(vec[205] == true);
2472		try expect(vec[206] == true);
2473		try expect(vec[207] == false);
2474		try expect(vec[208] == false);
2475		try expect(vec[209] == false);
2476		try expect(vec[210] == true);
2477		try expect(vec[211] == true);
2478		try expect(vec[212] == true);
2479		try expect(vec[213] == false);
2480		try expect(vec[214] == true);
2481		try expect(vec[215] == false);
2482		try expect(vec[216] == true);
2483		try expect(vec[217] == false);
2484		try expect(vec[218] == true);
2485		try expect(vec[219] == false);
2486		try expect(vec[220] == true);
2487		try expect(vec[221] == true);
2488		try expect(vec[222] == true);
2489		try expect(vec[223] == false);
2490		try expect(vec[224] == true);
2491		try expect(vec[225] == false);
2492		try expect(vec[226] == true);
2493		try expect(vec[227] == false);
2494		try expect(vec[228] == true);
2495		try expect(vec[229] == false);
2496		try expect(vec[230] == true);
2497		try expect(vec[231] == false);
2498		try expect(vec[232] == false);
2499		try expect(vec[233] == true);
2500		try expect(vec[234] == false);
2501		try expect(vec[235] == true);
2502		try expect(vec[236] == true);
2503		try expect(vec[237] == false);
2504		try expect(vec[238] == false);
2505		try expect(vec[239] == true);
2506		try expect(vec[240] == false);
2507		try expect(vec[241] == false);
2508		try expect(vec[242] == false);
2509		try expect(vec[243] == true);
2510		try expect(vec[244] == true);
2511		try expect(vec[245] == false);
2512		try expect(vec[246] == false);
2513		try expect(vec[247] == false);
2514		try expect(vec[248] == false);
2515		try expect(vec[249] == false);
2516		try expect(vec[250] == true);
2517		try expect(vec[251] == false);
2518		try expect(vec[252] == true);
2519		try expect(vec[253] == false);
2520		try expect(vec[254] == false);
2521		try expect(vec[255] == false);
2522		}
2523		{
2524		if (!builtin.target.cpu.arch.isWasm()) c_vector_512_bool(.{
2525		true,
2526		true,
2527		true,
2528		true,
2529		true,
2530		false,
2531		false,
2532		true,
2533		true,
2534		true,
2535		true,
2536		false,
2537		true,
2538		true,
2539		false,
2540		false,
2541		false,
2542		true,
2543		true,
2544		true,
2545		true,
2546		true,
2547		false,
2548		false,
2549		true,
2550		true,
2551		false,
2552		false,
2553		false,
2554		false,
2555		false,
2556		true,
2557		true,
2558		false,
2559		true,
2560		true,
2561		true,
2562		true,
2563		true,
2564		true,
2565		false,
2566		true,
2567		true,
2568		false,
2569		false,
2570		false,
2571		true,
2572		true,
2573		false,
2574		true,
2575		false,
2576		true,
2577		true,
2578		false,
2579		true,
2580		false,
2581		false,
2582		true,
2583		true,
2584		false,
2585		true,
2586		true,
2587		false,
2588		true,
2589		false,
2590		true,
2591		true,
2592		true,
2593		true,
2594		true,
2595		true,
2596		true,
2597		true,
2598		true,
2599		false,
2600		true,
2601		false,
2602		true,
2603		false,
2604		false,
2605		false,
2606		true,
2607		false,
2608		true,
2609		true,
2610		false,
2611		true,
2612		true,
2613		true,
2614		false,
2615		true,
2616		true,
2617		false,
2618		true,
2619		false,
2620		true,
2621		true,
2622		false,
2623		false,
2624		false,
2625		true,
2626		true,
2627		false,
2628		true,
2629		false,
2630		false,
2631		true,
2632		false,
2633		false,
2634		true,
2635		false,
2636		false,
2637		false,
2638		false,
2639		false,
2640		true,
2641		true,
2642		false,
2643		false,
2644		false,
2645		false,
2646		true,
2647		false,
2648		false,
2649		true,
2650		true,
2651		false,
2652		true,
2653		false,
2654		true,
2655		true,
2656		false,
2657		true,
2658		false,
2659		false,
2660		false,
2661		false,
2662		true,
2663		true,
2664		false,
2665		false,
2666		false,
2667		true,
2668		true,
2669		false,
2670		false,
2671		true,
2672		true,
2673		true,
2674		true,
2675		true,
2676		true,
2677		true,
2678		false,
2679		true,
2680		false,
2681		false,
2682		true,
2683		false,
2684		true,
2685		false,
2686		true,
2687		true,
2688		true,
2689		true,
2690		true,
2691		true,
2692		true,
2693		true,
2694		false,
2695		true,
2696		true,
2697		false,
2698		true,
2699		true,
2700		false,
2701		false,
2702		false,
2703		true,
2704		false,
2705		false,
2706		true,
2707		true,
2708		true,
2709		true,
2710		true,
2711		true,
2712		true,
2713		true,
2714		true,
2715		false,
2716		true,
2717		true,
2718		false,
2719		false,
2720		true,
2721		true,
2722		false,
2723		true,
2724		true,
2725		false,
2726		true,
2727		true,
2728		false,
2729		true,
2730		true,
2731		true,
2732		true,
2733		false,
2734		true,
2735		false,
2736		true,
2737		true,
2738		false,
2739		true,
2740		false,
2741		true,
2742		false,
2743		true,
2744		false,
2745		false,
2746		true,
2747		false,
2748		false,
2749		false,
2750		true,
2751		true,
2752		false,
2753		false,
2754		false,
2755		true,
2756		false,
2757		true,
2758		false,
2759		false,
2760		false,
2761		true,
2762		true,
2763		false,
2764		false,
2765		false,
2766		false,
2767		false,
2768		true,
2769		true,
2770		false,
2771		true,
2772		false,
2773		false,
2774		true,
2775		false,
2776		false,
2777		false,
2778		true,
2779		false,
2780		false,
2781		false,
2782		false,
2783		true,
2784		true,
2785		true,
2786		true,
2787		false,
2788		true,
2789		false,
2790		false,
2791		false,
2792		true,
2793		false,
2794		false,
2795		true,
2796		true,
2797		false,
2798		false,
2799		false,
2800		false,
2801		false,
2802		true,
2803		false,
2804		true,
2805		true,
2806		true,
2807		true,
2808		true,
2809		false,
2810		false,
2811		false,
2812		false,
2813		false,
2814		false,
2815		false,
2816		false,
2817		false,
2818		true,
2819		true,
2820		true,
2821		true,
2822		true,
2823		true,
2824		false,
2825		true,
2826		false,
2827		true,
2828		true,
2829		true,
2830		false,
2831		false,
2832		true,
2833		true,
2834		true,
2835		false,
2836		true,
2837		true,
2838		true,
2839		false,
2840		true,
2841		true,
2842		true,
2843		false,
2844		true,
2845		true,
2846		false,
2847		false,
2848		true,
2849		false,
2850		false,
2851		false,
2852		false,
2853		true,
2854		false,
2855		true,
2856		true,
2857		true,
2858		true,
2859		false,
2860		false,
2861		true,
2862		false,
2863		true,
2864		false,
2865		false,
2866		false,
2867		true,
2868		false,
2869		true,
2870		false,
2871		false,
2872		true,
2873		true,
2874		true,
2875		true,
2876		false,
2877		false,
2878		false,
2879		true,
2880		true,
2881		false,
2882		true,
2883		false,
2884		false,
2885		true,
2886		false,
2887		true,
2888		false,
2889		true,
2890		true,
2891		false,
2892		false,
2893		true,
2894		true,
2895		true,
2896		true,
2897		false,
2898		false,
2899		true,
2900		false,
2901		true,
2902		true,
2903		false,
2904		true,
2905		true,
2906		false,
2907		true,
2908		true,
2909		true,
2910		false,
2911		true,
2912		true,
2913		true,
2914		false,
2915		false,
2916		true,
2917		false,
2918		true,
2919		true,
2920		true,
2921		false,
2922		false,
2923		false,
2924		false,
2925		false,
2926		true,
2927		false,
2928		false,
2929		false,
2930		false,
2931		true,
2932		false,
2933		false,
2934		true,
2935		true,
2936		false,
2937		false,
2938		false,
2939		false,
2940		true,
2941		true,
2942		true,
2943		true,
2944		true,
2945		false,
2946		false,
2947		false,
2948		true,
2949		false,
2950		false,
2951		false,
2952		false,
2953		true,
2954		false,
2955		true,
2956		false,
2957		true,
2958		true,
2959		true,
2960		true,
2961		false,
2962		false,
2963		false,
2964		false,
2965		false,
2966		true,
2967		true,
2968		true,
2969		true,
2970		true,
2971		true,
2972		true,
2973		true,
2974		true,
2975		false,
2976		false,
2977		true,
2978		false,
2979		true,
2980		false,
2981		false,
2982		true,
2983		false,
2984		false,
2985		true,
2986		true,
2987		true,
2988		true,
2989		true,
2990		true,
2991		false,
2992		true,
2993		false,
2994		false,
2995		false,
2996		true,
2997		true,
2998		false,
2999		true,
3000		true,
3001		false,
3002		false,
3003		true,
3004		true,
3005		false,
3006		false,
3007		true,
3008		true,
3009		false,
3010		true,
3011		false,
3012		true,
3013		true,
3014		true,
3015		true,
3016		true,
3017		true,
3018		true,
3019		true,
3020		true,
3021		false,
3022		true,
3023		true,
3024		true,
3025		false,
3026		false,
3027		true,
3028		false,
3029		false,
3030		false,
3031		true,
3032		true,
3033		false,
3034		true,
3035		false,
3036		true,
3037		});
3038
3039		const vec = c_ret_vector_512_bool();
3040		try expect(vec[0] == false);
3041		try expect(vec[1] == true);
3042		try expect(vec[2] == false);
3043		try expect(vec[3] == false);
3044		try expect(vec[4] == false);
3045		try expect(vec[5] == true);
3046		try expect(vec[6] == false);
3047		try expect(vec[7] == false);
3048		try expect(vec[8] == false);
3049		try expect(vec[9] == true);
3050		try expect(vec[10] == false);
3051		try expect(vec[11] == false);
3052		try expect(vec[12] == false);
3053		try expect(vec[13] == true);
3054		try expect(vec[14] == false);
3055		try expect(vec[15] == true);
3056		try expect(vec[16] == false);
3057		try expect(vec[17] == false);
3058		try expect(vec[18] == false);
3059		try expect(vec[19] == false);
3060		try expect(vec[20] == false);
3061		try expect(vec[21] == false);
3062		try expect(vec[22] == true);
3063		try expect(vec[23] == true);
3064		try expect(vec[24] == false);
3065		try expect(vec[25] == false);
3066		try expect(vec[26] == false);
3067		try expect(vec[27] == false);
3068		try expect(vec[28] == true);
3069		try expect(vec[29] == true);
3070		try expect(vec[30] == false);
3071		try expect(vec[31] == true);
3072		try expect(vec[32] == false);
3073		try expect(vec[33] == true);
3074		try expect(vec[34] == true);
3075		try expect(vec[35] == true);
3076		try expect(vec[36] == false);
3077		try expect(vec[37] == false);
3078		try expect(vec[38] == true);
3079		try expect(vec[39] == true);
3080		try expect(vec[40] == false);
3081		try expect(vec[41] == false);
3082		try expect(vec[42] == false);
3083		try expect(vec[43] == false);
3084		try expect(vec[44] == false);
3085		try expect(vec[45] == true);
3086		try expect(vec[46] == false);
3087		try expect(vec[47] == true);
3088		try expect(vec[48] == true);
3089		try expect(vec[49] == false);
3090		try expect(vec[50] == true);
3091		try expect(vec[51] == true);
3092		try expect(vec[52] == true);
3093		try expect(vec[53] == true);
3094		try expect(vec[54] == false);
3095		try expect(vec[55] == false);
3096		try expect(vec[56] == false);
3097		try expect(vec[57] == true);
3098		try expect(vec[58] == true);
3099		try expect(vec[59] == false);
3100		try expect(vec[60] == false);
3101		try expect(vec[61] == false);
3102		try expect(vec[62] == false);
3103		try expect(vec[63] == true);
3104		try expect(vec[64] == true);
3105		try expect(vec[65] == true);
3106		try expect(vec[66] == true);
3107		try expect(vec[67] == true);
3108		try expect(vec[68] == false);
3109		try expect(vec[69] == false);
3110		try expect(vec[70] == false);
3111		try expect(vec[71] == false);
3112		try expect(vec[72] == false);
3113		try expect(vec[73] == true);
3114		try expect(vec[74] == false);
3115		try expect(vec[75] == true);
3116		try expect(vec[76] == false);
3117		try expect(vec[77] == false);
3118		try expect(vec[78] == true);
3119		try expect(vec[79] == true);
3120		try expect(vec[80] == false);
3121		try expect(vec[81] == false);
3122		try expect(vec[82] == false);
3123		try expect(vec[83] == true);
3124		try expect(vec[84] == false);
3125		try expect(vec[85] == true);
3126		try expect(vec[86] == true);
3127		try expect(vec[87] == true);
3128		try expect(vec[88] == false);
3129		try expect(vec[89] == true);
3130		try expect(vec[90] == false);
3131		try expect(vec[91] == false);
3132		try expect(vec[92] == true);
3133		try expect(vec[93] == true);
3134		try expect(vec[94] == false);
3135		try expect(vec[95] == true);
3136		try expect(vec[96] == true);
3137		try expect(vec[97] == false);
3138		try expect(vec[98] == true);
3139		try expect(vec[99] == false);
3140		try expect(vec[100] == true);
3141		try expect(vec[101] == true);
3142		try expect(vec[102] == false);
3143		try expect(vec[103] == true);
3144		try expect(vec[104] == true);
3145		try expect(vec[105] == false);
3146		try expect(vec[106] == false);
3147		try expect(vec[107] == false);
3148		try expect(vec[108] == true);
3149		try expect(vec[109] == false);
3150		try expect(vec[110] == false);
3151		try expect(vec[111] == false);
3152		try expect(vec[112] == true);
3153		try expect(vec[113] == true);
3154		try expect(vec[114] == true);
3155		try expect(vec[115] == false);
3156		try expect(vec[116] == true);
3157		try expect(vec[117] == false);
3158		try expect(vec[118] == true);
3159		try expect(vec[119] == false);
3160		try expect(vec[120] == true);
3161		try expect(vec[121] == true);
3162		try expect(vec[122] == false);
3163		try expect(vec[123] == true);
3164		try expect(vec[124] == false);
3165		try expect(vec[125] == true);
3166		try expect(vec[126] == true);
3167		try expect(vec[127] == true);
3168		try expect(vec[128] == false);
3169		try expect(vec[129] == true);
3170		try expect(vec[130] == false);
3171		try expect(vec[131] == false);
3172		try expect(vec[132] == false);
3173		try expect(vec[133] == false);
3174		try expect(vec[134] == false);
3175		try expect(vec[135] == false);
3176		try expect(vec[136] == true);
3177		try expect(vec[137] == false);
3178		try expect(vec[138] == true);
3179		try expect(vec[139] == false);
3180		try expect(vec[140] == true);
3181		try expect(vec[141] == true);
3182		try expect(vec[142] == false);
3183		try expect(vec[143] == true);
3184		try expect(vec[144] == false);
3185		try expect(vec[145] == false);
3186		try expect(vec[146] == true);
3187		try expect(vec[147] == false);
3188		try expect(vec[148] == false);
3189		try expect(vec[149] == true);
3190		try expect(vec[150] == false);
3191		try expect(vec[151] == true);
3192		try expect(vec[152] == false);
3193		try expect(vec[153] == true);
3194		try expect(vec[154] == false);
3195		try expect(vec[155] == false);
3196		try expect(vec[156] == true);
3197		try expect(vec[157] == false);
3198		try expect(vec[158] == true);
3199		try expect(vec[159] == true);
3200		try expect(vec[160] == true);
3201		try expect(vec[161] == false);
3202		try expect(vec[162] == false);
3203		try expect(vec[163] == true);
3204		try expect(vec[164] == false);
3205		try expect(vec[165] == false);
3206		try expect(vec[166] == false);
3207		try expect(vec[167] == true);
3208		try expect(vec[168] == true);
3209		try expect(vec[169] == true);
3210		try expect(vec[170] == false);
3211		try expect(vec[171] == true);
3212		try expect(vec[172] == false);
3213		try expect(vec[173] == false);
3214		try expect(vec[174] == false);
3215		try expect(vec[175] == false);
3216		try expect(vec[176] == false);
3217		try expect(vec[177] == true);
3218		try expect(vec[178] == true);
3219		try expect(vec[179] == false);
3220		try expect(vec[180] == false);
3221		try expect(vec[181] == true);
3222		try expect(vec[182] == false);
3223		try expect(vec[183] == false);
3224		try expect(vec[184] == false);
3225		try expect(vec[185] == false);
3226		try expect(vec[186] == false);
3227		try expect(vec[187] == true);
3228		try expect(vec[188] == true);
3229		try expect(vec[189] == false);
3230		try expect(vec[190] == false);
3231		try expect(vec[191] == false);
3232		try expect(vec[192] == false);
3233		try expect(vec[193] == false);
3234		try expect(vec[194] == false);
3235		try expect(vec[195] == true);
3236		try expect(vec[196] == true);
3237		try expect(vec[197] == false);
3238		try expect(vec[198] == true);
3239		try expect(vec[199] == true);
3240		try expect(vec[200] == true);
3241		try expect(vec[201] == true);
3242		try expect(vec[202] == true);
3243		try expect(vec[203] == true);
3244		try expect(vec[204] == false);
3245		try expect(vec[205] == false);
3246		try expect(vec[206] == false);
3247		try expect(vec[207] == false);
3248		try expect(vec[208] == true);
3249		try expect(vec[209] == false);
3250		try expect(vec[210] == true);
3251		try expect(vec[211] == true);
3252		try expect(vec[212] == true);
3253		try expect(vec[213] == true);
3254		try expect(vec[214] == false);
3255		try expect(vec[215] == false);
3256		try expect(vec[216] == false);
3257		try expect(vec[217] == true);
3258		try expect(vec[218] == true);
3259		try expect(vec[219] == false);
3260		try expect(vec[220] == true);
3261		try expect(vec[221] == true);
3262		try expect(vec[222] == false);
3263		try expect(vec[223] == false);
3264		try expect(vec[224] == false);
3265		try expect(vec[225] == true);
3266		try expect(vec[226] == true);
3267		try expect(vec[227] == true);
3268		try expect(vec[228] == true);
3269		try expect(vec[229] == false);
3270		try expect(vec[230] == true);
3271		try expect(vec[231] == false);
3272		try expect(vec[232] == true);
3273		try expect(vec[233] == true);
3274		try expect(vec[234] == true);
3275		try expect(vec[235] == true);
3276		try expect(vec[236] == false);
3277		try expect(vec[237] == true);
3278		try expect(vec[238] == false);
3279		try expect(vec[239] == true);
3280		try expect(vec[240] == false);
3281		try expect(vec[241] == true);
3282		try expect(vec[242] == false);
3283		try expect(vec[243] == false);
3284		try expect(vec[244] == false);
3285		try expect(vec[245] == true);
3286		try expect(vec[246] == true);
3287		try expect(vec[247] == false);
3288		try expect(vec[248] == true);
3289		try expect(vec[249] == false);
3290		try expect(vec[250] == false);
3291		try expect(vec[251] == false);
3292		try expect(vec[252] == true);
3293		try expect(vec[253] == true);
3294		try expect(vec[254] == true);
3295		try expect(vec[255] == true);
3296		try expect(vec[256] == true);
3297		try expect(vec[257] == false);
3298		try expect(vec[258] == true);
3299		try expect(vec[259] == true);
3300		try expect(vec[260] == true);
3301		try expect(vec[261] == true);
3302		try expect(vec[262] == false);
3303		try expect(vec[263] == true);
3304		try expect(vec[264] == false);
3305		try expect(vec[265] == false);
3306		try expect(vec[266] == true);
3307		try expect(vec[267] == false);
3308		try expect(vec[268] == true);
3309		try expect(vec[269] == false);
3310		try expect(vec[270] == false);
3311		try expect(vec[271] == true);
3312		try expect(vec[272] == true);
3313		try expect(vec[273] == false);
3314		try expect(vec[274] == true);
3315		try expect(vec[275] == false);
3316		try expect(vec[276] == false);
3317		try expect(vec[277] == true);
3318		try expect(vec[278] == false);
3319		try expect(vec[279] == false);
3320		try expect(vec[280] == true);
3321		try expect(vec[281] == true);
3322		try expect(vec[282] == true);
3323		try expect(vec[283] == false);
3324		try expect(vec[284] == false);
3325		try expect(vec[285] == true);
3326		try expect(vec[286] == true);
3327		try expect(vec[287] == true);
3328		try expect(vec[288] == false);
3329		try expect(vec[289] == false);
3330		try expect(vec[290] == false);
3331		try expect(vec[291] == false);
3332		try expect(vec[292] == false);
3333		try expect(vec[293] == false);
3334		try expect(vec[294] == true);
3335		try expect(vec[295] == false);
3336		try expect(vec[296] == true);
3337		try expect(vec[297] == false);
3338		try expect(vec[298] == true);
3339		try expect(vec[299] == true);
3340		try expect(vec[300] == false);
3341		try expect(vec[301] == false);
3342		try expect(vec[302] == false);
3343		try expect(vec[303] == false);
3344		try expect(vec[304] == true);
3345		try expect(vec[305] == true);
3346		try expect(vec[306] == true);
3347		try expect(vec[307] == true);
3348		try expect(vec[308] == true);
3349		try expect(vec[309] == false);
3350		try expect(vec[310] == true);
3351		try expect(vec[311] == true);
3352		try expect(vec[312] == true);
3353		try expect(vec[313] == true);
3354		try expect(vec[314] == true);
3355		try expect(vec[315] == false);
3356		try expect(vec[316] == true);
3357		try expect(vec[317] == true);
3358		try expect(vec[318] == true);
3359		try expect(vec[319] == false);
3360		try expect(vec[320] == true);
3361		try expect(vec[321] == false);
3362		try expect(vec[322] == true);
3363		try expect(vec[323] == true);
3364		try expect(vec[324] == true);
3365		try expect(vec[325] == false);
3366		try expect(vec[326] == false);
3367		try expect(vec[327] == true);
3368		try expect(vec[328] == true);
3369		try expect(vec[329] == true);
3370		try expect(vec[330] == false);
3371		try expect(vec[331] == false);
3372		try expect(vec[332] == true);
3373		try expect(vec[333] == true);
3374		try expect(vec[334] == false);
3375		try expect(vec[335] == true);
3376		try expect(vec[336] == true);
3377		try expect(vec[337] == true);
3378		try expect(vec[338] == true);
3379		try expect(vec[339] == true);
3380		try expect(vec[340] == true);
3381		try expect(vec[341] == false);
3382		try expect(vec[342] == true);
3383		try expect(vec[343] == false);
3384		try expect(vec[344] == true);
3385		try expect(vec[345] == false);
3386		try expect(vec[346] == false);
3387		try expect(vec[347] == false);
3388		try expect(vec[348] == false);
3389		try expect(vec[349] == true);
3390		try expect(vec[350] == true);
3391		try expect(vec[351] == true);
3392		try expect(vec[352] == true);
3393		try expect(vec[353] == false);
3394		try expect(vec[354] == true);
3395		try expect(vec[355] == false);
3396		try expect(vec[356] == true);
3397		try expect(vec[357] == true);
3398		try expect(vec[358] == false);
3399		try expect(vec[359] == true);
3400		try expect(vec[360] == false);
3401		try expect(vec[361] == false);
3402		try expect(vec[362] == true);
3403		try expect(vec[363] == false);
3404		try expect(vec[364] == false);
3405		try expect(vec[365] == false);
3406		try expect(vec[366] == false);
3407		try expect(vec[367] == false);
3408		try expect(vec[368] == false);
3409		try expect(vec[369] == false);
3410		try expect(vec[370] == true);
3411		try expect(vec[371] == false);
3412		try expect(vec[372] == true);
3413		try expect(vec[373] == true);
3414		try expect(vec[374] == false);
3415		try expect(vec[375] == false);
3416		try expect(vec[376] == true);
3417		try expect(vec[377] == false);
3418		try expect(vec[378] == false);
3419		try expect(vec[379] == true);
3420		try expect(vec[380] == false);
3421		try expect(vec[381] == false);
3422		try expect(vec[382] == true);
3423		try expect(vec[383] == false);
3424		try expect(vec[384] == false);
3425		try expect(vec[385] == false);
3426		try expect(vec[386] == false);
3427		try expect(vec[387] == true);
3428		try expect(vec[388] == true);
3429		try expect(vec[389] == true);
3430		try expect(vec[390] == true);
3431		try expect(vec[391] == true);
3432		try expect(vec[392] == true);
3433		try expect(vec[393] == true);
3434		try expect(vec[394] == false);
3435		try expect(vec[395] == true);
3436		try expect(vec[396] == true);
3437		try expect(vec[397] == false);
3438		try expect(vec[398] == false);
3439		try expect(vec[399] == false);
3440		try expect(vec[400] == true);
3441		try expect(vec[401] == false);
3442		try expect(vec[402] == true);
3443		try expect(vec[403] == true);
3444		try expect(vec[404] == false);
3445		try expect(vec[405] == true);
3446		try expect(vec[406] == true);
3447		try expect(vec[407] == true);
3448		try expect(vec[408] == true);
3449		try expect(vec[409] == false);
3450		try expect(vec[410] == false);
3451		try expect(vec[411] == false);
3452		try expect(vec[412] == true);
3453		try expect(vec[413] == true);
3454		try expect(vec[414] == false);
3455		try expect(vec[415] == true);
3456		try expect(vec[416] == false);
3457		try expect(vec[417] == true);
3458		try expect(vec[418] == false);
3459		try expect(vec[419] == false);
3460		try expect(vec[420] == false);
3461		try expect(vec[421] == false);
3462		try expect(vec[422] == true);
3463		try expect(vec[423] == true);
3464		try expect(vec[424] == true);
3465		try expect(vec[425] == false);
3466		try expect(vec[426] == true);
3467		try expect(vec[427] == false);
3468		try expect(vec[428] == false);
3469		try expect(vec[429] == false);
3470		try expect(vec[430] == true);
3471		try expect(vec[431] == true);
3472		try expect(vec[432] == false);
3473		try expect(vec[433] == true);
3474		try expect(vec[434] == false);
3475		try expect(vec[435] == false);
3476		try expect(vec[436] == true);
3477		try expect(vec[437] == true);
3478		try expect(vec[438] == true);
3479		try expect(vec[439] == true);
3480		try expect(vec[440] == true);
3481		try expect(vec[441] == true);
3482		try expect(vec[442] == false);
3483		try expect(vec[443] == false);
3484		try expect(vec[444] == false);
3485		try expect(vec[445] == true);
3486		try expect(vec[446] == true);
3487		try expect(vec[447] == true);
3488		try expect(vec[448] == false);
3489		try expect(vec[449] == false);
3490		try expect(vec[450] == false);
3491		try expect(vec[451] == false);
3492		try expect(vec[452] == false);
3493		try expect(vec[453] == false);
3494		try expect(vec[454] == false);
3495		try expect(vec[455] == false);
3496		try expect(vec[456] == false);
3497		try expect(vec[457] == false);
3498		try expect(vec[458] == false);
3499		try expect(vec[459] == true);
3500		try expect(vec[460] == false);
3501		try expect(vec[461] == false);
3502		try expect(vec[462] == false);
3503		try expect(vec[463] == true);
3504		try expect(vec[464] == false);
3505		try expect(vec[465] == false);
3506		try expect(vec[466] == false);
3507		try expect(vec[467] == false);
3508		try expect(vec[468] == true);
3509		try expect(vec[469] == true);
3510		try expect(vec[470] == true);
3511		try expect(vec[471] == true);
3512		try expect(vec[472] == true);
3513		try expect(vec[473] == false);
3514		try expect(vec[474] == false);
3515		try expect(vec[475] == true);
3516		try expect(vec[476] == true);
3517		try expect(vec[477] == true);
3518		try expect(vec[478] == false);
3519		try expect(vec[479] == true);
3520		try expect(vec[480] == true);
3521		try expect(vec[481] == true);
3522		try expect(vec[482] == false);
3523		try expect(vec[483] == true);
3524		try expect(vec[484] == false);
3525		try expect(vec[485] == true);
3526		try expect(vec[486] == false);
3527		try expect(vec[487] == true);
3528		try expect(vec[488] == false);
3529		try expect(vec[489] == true);
3530		try expect(vec[490] == true);
3531		try expect(vec[491] == true);
3532		try expect(vec[492] == true);
3533		try expect(vec[493] == false);
3534		try expect(vec[494] == true);
3535		try expect(vec[495] == true);
3536		try expect(vec[496] == false);
3537		try expect(vec[497] == true);
3538		try expect(vec[498] == false);
3539		try expect(vec[499] == false);
3540		try expect(vec[500] == false);
3541		try expect(vec[501] == false);
3542		try expect(vec[502] == false);
3543		try expect(vec[503] == false);
3544		try expect(vec[504] == false);
3545		try expect(vec[505] == false);
3546		try expect(vec[506] == false);
3547		try expect(vec[507] == true);
3548		try expect(vec[508] == true);
3549		try expect(vec[509] == false);
3550		try expect(vec[510] == true);
3551		try expect(vec[511] == false);
3552		}
3553		}
3554
3555		comptime {
3556		skip: {
3557		if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
3558		if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip;
3559
3560		_ = struct {
3561		export fn zig_vector_2_bool(vec: Vector2Bool) void {
3562		expect(vec[0] == false) catch @panic("test failure");
3563		expect(vec[1] == true) catch @panic("test failure");
3564		}
3565
3566		export fn zig_vector_4_bool(vec: Vector4Bool) void {
3567		expect(vec[0] == false) catch @panic("test failure");
3568		expect(vec[1] == false) catch @panic("test failure");
3569		expect(vec[2] == false) catch @panic("test failure");
3570		expect(vec[3] == false) catch @panic("test failure");
3571		}
3572
3573		export fn zig_vector_8_bool(vec: Vector8Bool) void {
3574		expect(vec[0] == true) catch @panic("test failure");
3575		expect(vec[1] == true) catch @panic("test failure");
3576		expect(vec[2] == false) catch @panic("test failure");
3577		expect(vec[3] == true) catch @panic("test failure");
3578		expect(vec[4] == false) catch @panic("test failure");
3579		expect(vec[5] == true) catch @panic("test failure");
3580		expect(vec[6] == true) catch @panic("test failure");
3581		expect(vec[7] == false) catch @panic("test failure");
3582		}
3583
3584		export fn zig_vector_16_bool(vec: Vector16Bool) void {
3585		expect(vec[0] == true) catch @panic("test failure");
3586		expect(vec[1] == false) catch @panic("test failure");
3587		expect(vec[2] == true) catch @panic("test failure");
3588		expect(vec[3] == true) catch @panic("test failure");
3589		expect(vec[4] == true) catch @panic("test failure");
3590		expect(vec[5] == false) catch @panic("test failure");
3591		expect(vec[6] == false) catch @panic("test failure");
3592		expect(vec[7] == false) catch @panic("test failure");
3593		expect(vec[8] == true) catch @panic("test failure");
3594		expect(vec[9] == true) catch @panic("test failure");
3595		expect(vec[10] == true) catch @panic("test failure");
3596		expect(vec[11] == true) catch @panic("test failure");
3597		expect(vec[12] == false) catch @panic("test failure");
3598		expect(vec[13] == false) catch @panic("test failure");
3599		expect(vec[14] == false) catch @panic("test failure");
3600		expect(vec[15] == true) catch @panic("test failure");
3601		}
3602
3603		export fn zig_vector_32_bool(vec: Vector32Bool) void {
3604		expect(vec[0] == false) catch @panic("test failure");
3605		expect(vec[1] == false) catch @panic("test failure");
3606		expect(vec[2] == false) catch @panic("test failure");
3607		expect(vec[3] == true) catch @panic("test failure");
3608		expect(vec[4] == true) catch @panic("test failure");
3609		expect(vec[5] == false) catch @panic("test failure");
3610		expect(vec[6] == false) catch @panic("test failure");
3611		expect(vec[7] == true) catch @panic("test failure");
3612		expect(vec[8] == false) catch @panic("test failure");
3613		expect(vec[9] == true) catch @panic("test failure");
3614		expect(vec[10] == true) catch @panic("test failure");
3615		expect(vec[11] == true) catch @panic("test failure");
3616		expect(vec[12] == false) catch @panic("test failure");
3617		expect(vec[13] == false) catch @panic("test failure");
3618		expect(vec[14] == true) catch @panic("test failure");
3619		expect(vec[15] == true) catch @panic("test failure");
3620		expect(vec[16] == true) catch @panic("test failure");
3621		expect(vec[17] == true) catch @panic("test failure");
3622		expect(vec[18] == true) catch @panic("test failure");
3623		expect(vec[19] == false) catch @panic("test failure");
3624		expect(vec[20] == true) catch @panic("test failure");
3625		expect(vec[21] == true) catch @panic("test failure");
3626		expect(vec[22] == true) catch @panic("test failure");
3627		expect(vec[23] == false) catch @panic("test failure");
3628		expect(vec[24] == false) catch @panic("test failure");
3629		expect(vec[25] == true) catch @panic("test failure");
3630		expect(vec[26] == true) catch @panic("test failure");
3631		expect(vec[27] == false) catch @panic("test failure");
3632		expect(vec[28] == true) catch @panic("test failure");
3633		expect(vec[29] == true) catch @panic("test failure");
3634		expect(vec[30] == false) catch @panic("test failure");
3635		expect(vec[31] == true) catch @panic("test failure");
3636		}
3637
3638		export fn zig_vector_64_bool(vec: Vector64Bool) void {
3639		expect(vec[0] == true) catch @panic("test failure");
3640		expect(vec[1] == true) catch @panic("test failure");
3641		expect(vec[2] == false) catch @panic("test failure");
3642		expect(vec[3] == true) catch @panic("test failure");
3643		expect(vec[4] == false) catch @panic("test failure");
3644		expect(vec[5] == true) catch @panic("test failure");
3645		expect(vec[6] == false) catch @panic("test failure");
3646		expect(vec[7] == false) catch @panic("test failure");
3647		expect(vec[8] == true) catch @panic("test failure");
3648		expect(vec[9] == true) catch @panic("test failure");
3649		expect(vec[10] == true) catch @panic("test failure");
3650		expect(vec[11] == true) catch @panic("test failure");
3651		expect(vec[12] == true) catch @panic("test failure");
3652		expect(vec[13] == true) catch @panic("test failure");
3653		expect(vec[14] == true) catch @panic("test failure");
3654		expect(vec[15] == false) catch @panic("test failure");
3655		expect(vec[16] == false) catch @panic("test failure");
3656		expect(vec[17] == true) catch @panic("test failure");
3657		expect(vec[18] == true) catch @panic("test failure");
3658		expect(vec[19] == false) catch @panic("test failure");
3659		expect(vec[20] == true) catch @panic("test failure");
3660		expect(vec[21] == true) catch @panic("test failure");
3661		expect(vec[22] == true) catch @panic("test failure");
3662		expect(vec[23] == true) catch @panic("test failure");
3663		expect(vec[24] == false) catch @panic("test failure");
3664		expect(vec[25] == false) catch @panic("test failure");
3665		expect(vec[26] == true) catch @panic("test failure");
3666		expect(vec[27] == false) catch @panic("test failure");
3667		expect(vec[28] == false) catch @panic("test failure");
3668		expect(vec[29] == true) catch @panic("test failure");
3669		expect(vec[30] == false) catch @panic("test failure");
3670		expect(vec[31] == true) catch @panic("test failure");
3671		expect(vec[32] == false) catch @panic("test failure");
3672		expect(vec[33] == true) catch @panic("test failure");
3673		expect(vec[34] == true) catch @panic("test failure");
3674		expect(vec[35] == false) catch @panic("test failure");
3675		expect(vec[36] == true) catch @panic("test failure");
3676		expect(vec[37] == true) catch @panic("test failure");
3677		expect(vec[38] == false) catch @panic("test failure");
3678		expect(vec[39] == false) catch @panic("test failure");
3679		expect(vec[40] == true) catch @panic("test failure");
3680		expect(vec[41] == true) catch @panic("test failure");
3681		expect(vec[42] == true) catch @panic("test failure");
3682		expect(vec[43] == true) catch @panic("test failure");
3683		expect(vec[44] == true) catch @panic("test failure");
3684		expect(vec[45] == false) catch @panic("test failure");
3685		expect(vec[46] == true) catch @panic("test failure");
3686		expect(vec[47] == false) catch @panic("test failure");
3687		expect(vec[48] == false) catch @panic("test failure");
3688		expect(vec[49] == false) catch @panic("test failure");
3689		expect(vec[50] == false) catch @panic("test failure");
3690		expect(vec[51] == false) catch @panic("test failure");
3691		expect(vec[52] == true) catch @panic("test failure");
3692		expect(vec[53] == false) catch @panic("test failure");
3693		expect(vec[54] == false) catch @panic("test failure");
3694		expect(vec[55] == true) catch @panic("test failure");
3695		expect(vec[56] == true) catch @panic("test failure");
3696		expect(vec[57] == false) catch @panic("test failure");
3697		expect(vec[58] == false) catch @panic("test failure");
3698		expect(vec[59] == false) catch @panic("test failure");
3699		expect(vec[60] == true) catch @panic("test failure");
3700		expect(vec[61] == true) catch @panic("test failure");
3701		expect(vec[62] == true) catch @panic("test failure");
3702		expect(vec[63] == true) catch @panic("test failure");
3703		}
3704
3705		export fn zig_vector_128_bool(vec: Vector128Bool) void {
3706		expect(vec[0] == true) catch @panic("test failure");
3707		expect(vec[1] == true) catch @panic("test failure");
3708		expect(vec[2] == false) catch @panic("test failure");
3709		expect(vec[3] == true) catch @panic("test failure");
3710		expect(vec[4] == true) catch @panic("test failure");
3711		expect(vec[5] == false) catch @panic("test failure");
3712		expect(vec[6] == false) catch @panic("test failure");
3713		expect(vec[7] == true) catch @panic("test failure");
3714		expect(vec[8] == true) catch @panic("test failure");
3715		expect(vec[9] == true) catch @panic("test failure");
3716		expect(vec[10] == true) catch @panic("test failure");
3717		expect(vec[11] == true) catch @panic("test failure");
3718		expect(vec[12] == false) catch @panic("test failure");
3719		expect(vec[13] == false) catch @panic("test failure");
3720		expect(vec[14] == false) catch @panic("test failure");
3721		expect(vec[15] == true) catch @panic("test failure");
3722		expect(vec[16] == false) catch @panic("test failure");
3723		expect(vec[17] == true) catch @panic("test failure");
3724		expect(vec[18] == false) catch @panic("test failure");
3725		expect(vec[19] == false) catch @panic("test failure");
3726		expect(vec[20] == true) catch @panic("test failure");
3727		expect(vec[21] == false) catch @panic("test failure");
3728		expect(vec[22] == true) catch @panic("test failure");
3729		expect(vec[23] == false) catch @panic("test failure");
3730		expect(vec[24] == false) catch @panic("test failure");
3731		expect(vec[25] == false) catch @panic("test failure");
3732		expect(vec[26] == true) catch @panic("test failure");
3733		expect(vec[27] == false) catch @panic("test failure");
3734		expect(vec[28] == true) catch @panic("test failure");
3735		expect(vec[29] == true) catch @panic("test failure");
3736		expect(vec[30] == false) catch @panic("test failure");
3737		expect(vec[31] == true) catch @panic("test failure");
3738		expect(vec[32] == false) catch @panic("test failure");
3739		expect(vec[33] == true) catch @panic("test failure");
3740		expect(vec[34] == true) catch @panic("test failure");
3741		expect(vec[35] == false) catch @panic("test failure");
3742		expect(vec[36] == false) catch @panic("test failure");
3743		expect(vec[37] == false) catch @panic("test failure");
3744		expect(vec[38] == false) catch @panic("test failure");
3745		expect(vec[39] == true) catch @panic("test failure");
3746		expect(vec[40] == true) catch @panic("test failure");
3747		expect(vec[41] == false) catch @panic("test failure");
3748		expect(vec[42] == true) catch @panic("test failure");
3749		expect(vec[43] == false) catch @panic("test failure");
3750		expect(vec[44] == false) catch @panic("test failure");
3751		expect(vec[45] == true) catch @panic("test failure");
3752		expect(vec[46] == false) catch @panic("test failure");
3753		expect(vec[47] == false) catch @panic("test failure");
3754		expect(vec[48] == true) catch @panic("test failure");
3755		expect(vec[49] == true) catch @panic("test failure");
3756		expect(vec[50] == false) catch @panic("test failure");
3757		expect(vec[51] == false) catch @panic("test failure");
3758		expect(vec[52] == true) catch @panic("test failure");
3759		expect(vec[53] == false) catch @panic("test failure");
3760		expect(vec[54] == false) catch @panic("test failure");
3761		expect(vec[55] == true) catch @panic("test failure");
3762		expect(vec[56] == true) catch @panic("test failure");
3763		expect(vec[57] == true) catch @panic("test failure");
3764		expect(vec[58] == true) catch @panic("test failure");
3765		expect(vec[59] == true) catch @panic("test failure");
3766		expect(vec[60] == true) catch @panic("test failure");
3767		expect(vec[61] == true) catch @panic("test failure");
3768		expect(vec[62] == true) catch @panic("test failure");
3769		expect(vec[63] == false) catch @panic("test failure");
3770		expect(vec[64] == false) catch @panic("test failure");
3771		expect(vec[65] == true) catch @panic("test failure");
3772		expect(vec[66] == false) catch @panic("test failure");
3773		expect(vec[67] == true) catch @panic("test failure");
3774		expect(vec[68] == true) catch @panic("test failure");
3775		expect(vec[69] == true) catch @panic("test failure");
3776		expect(vec[70] == true) catch @panic("test failure");
3777		expect(vec[71] == false) catch @panic("test failure");
3778		expect(vec[72] == false) catch @panic("test failure");
3779		expect(vec[73] == false) catch @panic("test failure");
3780		expect(vec[74] == true) catch @panic("test failure");
3781		expect(vec[75] == true) catch @panic("test failure");
3782		expect(vec[76] == false) catch @panic("test failure");
3783		expect(vec[77] == true) catch @panic("test failure");
3784		expect(vec[78] == true) catch @panic("test failure");
3785		expect(vec[79] == true) catch @panic("test failure");
3786		expect(vec[80] == true) catch @panic("test failure");
3787		expect(vec[81] == false) catch @panic("test failure");
3788		expect(vec[82] == true) catch @panic("test failure");
3789		expect(vec[83] == true) catch @panic("test failure");
3790		expect(vec[84] == true) catch @panic("test failure");
3791		expect(vec[85] == true) catch @panic("test failure");
3792		expect(vec[86] == true) catch @panic("test failure");
3793		expect(vec[87] == true) catch @panic("test failure");
3794		expect(vec[88] == false) catch @panic("test failure");
3795		expect(vec[89] == true) catch @panic("test failure");
3796		expect(vec[90] == true) catch @panic("test failure");
3797		expect(vec[91] == true) catch @panic("test failure");
3798		expect(vec[92] == true) catch @panic("test failure");
3799		expect(vec[93] == true) catch @panic("test failure");
3800		expect(vec[94] == true) catch @panic("test failure");
3801		expect(vec[95] == false) catch @panic("test failure");
3802		expect(vec[96] == false) catch @panic("test failure");
3803		expect(vec[97] == false) catch @panic("test failure");
3804		expect(vec[98] == true) catch @panic("test failure");
3805		expect(vec[99] == true) catch @panic("test failure");
3806		expect(vec[100] == true) catch @panic("test failure");
3807		expect(vec[101] == true) catch @panic("test failure");
3808		expect(vec[102] == true) catch @panic("test failure");
3809		expect(vec[103] == true) catch @panic("test failure");
3810		expect(vec[104] == true) catch @panic("test failure");
3811		expect(vec[105] == false) catch @panic("test failure");
3812		expect(vec[106] == false) catch @panic("test failure");
3813		expect(vec[107] == false) catch @panic("test failure");
3814		expect(vec[108] == false) catch @panic("test failure");
3815		expect(vec[109] == false) catch @panic("test failure");
3816		expect(vec[110] == true) catch @panic("test failure");
3817		expect(vec[111] == true) catch @panic("test failure");
3818		expect(vec[112] == true) catch @panic("test failure");
3819		expect(vec[113] == false) catch @panic("test failure");
3820		expect(vec[114] == false) catch @panic("test failure");
3821		expect(vec[115] == false) catch @panic("test failure");
3822		expect(vec[116] == false) catch @panic("test failure");
3823		expect(vec[117] == false) catch @panic("test failure");
3824		expect(vec[118] == true) catch @panic("test failure");
3825		expect(vec[119] == false) catch @panic("test failure");
3826		expect(vec[120] == false) catch @panic("test failure");
3827		expect(vec[121] == false) catch @panic("test failure");
3828		expect(vec[122] == false) catch @panic("test failure");
3829		expect(vec[123] == true) catch @panic("test failure");
3830		expect(vec[124] == true) catch @panic("test failure");
3831		expect(vec[125] == false) catch @panic("test failure");
3832		expect(vec[126] == true) catch @panic("test failure");
3833		expect(vec[127] == false) catch @panic("test failure");
3834		}
3835
3836		export fn zig_vector_256_bool(vec: Vector256Bool) void {
3837		expect(vec[0] == false) catch @panic("test failure");
3838		expect(vec[1] == false) catch @panic("test failure");
3839		expect(vec[2] == false) catch @panic("test failure");
3840		expect(vec[3] == false) catch @panic("test failure");
3841		expect(vec[4] == true) catch @panic("test failure");
3842		expect(vec[5] == true) catch @panic("test failure");
3843		expect(vec[6] == false) catch @panic("test failure");
3844		expect(vec[7] == false) catch @panic("test failure");
3845		expect(vec[8] == false) catch @panic("test failure");
3846		expect(vec[9] == true) catch @panic("test failure");
3847		expect(vec[10] == true) catch @panic("test failure");
3848		expect(vec[11] == false) catch @panic("test failure");
3849		expect(vec[12] == true) catch @panic("test failure");
3850		expect(vec[13] == false) catch @panic("test failure");
3851		expect(vec[14] == false) catch @panic("test failure");
3852		expect(vec[15] == false) catch @panic("test failure");
3853		expect(vec[16] == false) catch @panic("test failure");
3854		expect(vec[17] == true) catch @panic("test failure");
3855		expect(vec[18] == true) catch @panic("test failure");
3856		expect(vec[19] == true) catch @panic("test failure");
3857		expect(vec[20] == false) catch @panic("test failure");
3858		expect(vec[21] == true) catch @panic("test failure");
3859		expect(vec[22] == true) catch @panic("test failure");
3860		expect(vec[23] == false) catch @panic("test failure");
3861		expect(vec[24] == true) catch @panic("test failure");
3862		expect(vec[25] == false) catch @panic("test failure");
3863		expect(vec[26] == false) catch @panic("test failure");
3864		expect(vec[27] == true) catch @panic("test failure");
3865		expect(vec[28] == true) catch @panic("test failure");
3866		expect(vec[29] == true) catch @panic("test failure");
3867		expect(vec[30] == false) catch @panic("test failure");
3868		expect(vec[31] == true) catch @panic("test failure");
3869		expect(vec[32] == false) catch @panic("test failure");
3870		expect(vec[33] == true) catch @panic("test failure");
3871		expect(vec[34] == false) catch @panic("test failure");
3872		expect(vec[35] == false) catch @panic("test failure");
3873		expect(vec[36] == false) catch @panic("test failure");
3874		expect(vec[37] == true) catch @panic("test failure");
3875		expect(vec[38] == false) catch @panic("test failure");
3876		expect(vec[39] == false) catch @panic("test failure");
3877		expect(vec[40] == true) catch @panic("test failure");
3878		expect(vec[41] == true) catch @panic("test failure");
3879		expect(vec[42] == false) catch @panic("test failure");
3880		expect(vec[43] == true) catch @panic("test failure");
3881		expect(vec[44] == true) catch @panic("test failure");
3882		expect(vec[45] == false) catch @panic("test failure");
3883		expect(vec[46] == true) catch @panic("test failure");
3884		expect(vec[47] == false) catch @panic("test failure");
3885		expect(vec[48] == true) catch @panic("test failure");
3886		expect(vec[49] == false) catch @panic("test failure");
3887		expect(vec[50] == true) catch @panic("test failure");
3888		expect(vec[51] == false) catch @panic("test failure");
3889		expect(vec[52] == true) catch @panic("test failure");
3890		expect(vec[53] == true) catch @panic("test failure");
3891		expect(vec[54] == true) catch @panic("test failure");
3892		expect(vec[55] == false) catch @panic("test failure");
3893		expect(vec[56] == false) catch @panic("test failure");
3894		expect(vec[57] == true) catch @panic("test failure");
3895		expect(vec[58] == true) catch @panic("test failure");
3896		expect(vec[59] == false) catch @panic("test failure");
3897		expect(vec[60] == false) catch @panic("test failure");
3898		expect(vec[61] == true) catch @panic("test failure");
3899		expect(vec[62] == true) catch @panic("test failure");
3900		expect(vec[63] == false) catch @panic("test failure");
3901		expect(vec[64] == false) catch @panic("test failure");
3902		expect(vec[65] == false) catch @panic("test failure");
3903		expect(vec[66] == true) catch @panic("test failure");
3904		expect(vec[67] == true) catch @panic("test failure");
3905		expect(vec[68] == false) catch @panic("test failure");
3906		expect(vec[69] == true) catch @panic("test failure");
3907		expect(vec[70] == false) catch @panic("test failure");
3908		expect(vec[71] == true) catch @panic("test failure");
3909		expect(vec[72] == false) catch @panic("test failure");
3910		expect(vec[73] == true) catch @panic("test failure");
3911		expect(vec[74] == false) catch @panic("test failure");
3912		expect(vec[75] == false) catch @panic("test failure");
3913		expect(vec[76] == true) catch @panic("test failure");
3914		expect(vec[77] == false) catch @panic("test failure");
3915		expect(vec[78] == false) catch @panic("test failure");
3916		expect(vec[79] == false) catch @panic("test failure");
3917		expect(vec[80] == false) catch @panic("test failure");
3918		expect(vec[81] == false) catch @panic("test failure");
3919		expect(vec[82] == true) catch @panic("test failure");
3920		expect(vec[83] == false) catch @panic("test failure");
3921		expect(vec[84] == false) catch @panic("test failure");
3922		expect(vec[85] == false) catch @panic("test failure");
3923		expect(vec[86] == true) catch @panic("test failure");
3924		expect(vec[87] == true) catch @panic("test failure");
3925		expect(vec[88] == true) catch @panic("test failure");
3926		expect(vec[89] == false) catch @panic("test failure");
3927		expect(vec[90] == true) catch @panic("test failure");
3928		expect(vec[91] == false) catch @panic("test failure");
3929		expect(vec[92] == true) catch @panic("test failure");
3930		expect(vec[93] == false) catch @panic("test failure");
3931		expect(vec[94] == true) catch @panic("test failure");
3932		expect(vec[95] == true) catch @panic("test failure");
3933		expect(vec[96] == true) catch @panic("test failure");
3934		expect(vec[97] == true) catch @panic("test failure");
3935		expect(vec[98] == false) catch @panic("test failure");
3936		expect(vec[99] == true) catch @panic("test failure");
3937		expect(vec[100] == false) catch @panic("test failure");
3938		expect(vec[101] == true) catch @panic("test failure");
3939		expect(vec[102] == true) catch @panic("test failure");
3940		expect(vec[103] == false) catch @panic("test failure");
3941		expect(vec[104] == false) catch @panic("test failure");
3942		expect(vec[105] == true) catch @panic("test failure");
3943		expect(vec[106] == false) catch @panic("test failure");
3944		expect(vec[107] == true) catch @panic("test failure");
3945		expect(vec[108] == false) catch @panic("test failure");
3946		expect(vec[109] == false) catch @panic("test failure");
3947		expect(vec[110] == false) catch @panic("test failure");
3948		expect(vec[111] == false) catch @panic("test failure");
3949		expect(vec[112] == false) catch @panic("test failure");
3950		expect(vec[113] == false) catch @panic("test failure");
3951		expect(vec[114] == false) catch @panic("test failure");
3952		expect(vec[115] == false) catch @panic("test failure");
3953		expect(vec[116] == false) catch @panic("test failure");
3954		expect(vec[117] == false) catch @panic("test failure");
3955		expect(vec[118] == false) catch @panic("test failure");
3956		expect(vec[119] == false) catch @panic("test failure");
3957		expect(vec[120] == false) catch @panic("test failure");
3958		expect(vec[121] == false) catch @panic("test failure");
3959		expect(vec[122] == true) catch @panic("test failure");
3960		expect(vec[123] == true) catch @panic("test failure");
3961		expect(vec[124] == false) catch @panic("test failure");
3962		expect(vec[125] == false) catch @panic("test failure");
3963		expect(vec[126] == false) catch @panic("test failure");
3964		expect(vec[127] == true) catch @panic("test failure");
3965		expect(vec[128] == true) catch @panic("test failure");
3966		expect(vec[129] == true) catch @panic("test failure");
3967		expect(vec[130] == true) catch @panic("test failure");
3968		expect(vec[131] == false) catch @panic("test failure");
3969		expect(vec[132] == false) catch @panic("test failure");
3970		expect(vec[133] == false) catch @panic("test failure");
3971		expect(vec[134] == true) catch @panic("test failure");
3972		expect(vec[135] == true) catch @panic("test failure");
3973		expect(vec[136] == false) catch @panic("test failure");
3974		expect(vec[137] == false) catch @panic("test failure");
3975		expect(vec[138] == true) catch @panic("test failure");
3976		expect(vec[139] == true) catch @panic("test failure");
3977		expect(vec[140] == true) catch @panic("test failure");
3978		expect(vec[141] == true) catch @panic("test failure");
3979		expect(vec[142] == true) catch @panic("test failure");
3980		expect(vec[143] == false) catch @panic("test failure");
3981		expect(vec[144] == true) catch @panic("test failure");
3982		expect(vec[145] == true) catch @panic("test failure");
3983		expect(vec[146] == true) catch @panic("test failure");
3984		expect(vec[147] == false) catch @panic("test failure");
3985		expect(vec[148] == false) catch @panic("test failure");
3986		expect(vec[149] == false) catch @panic("test failure");
3987		expect(vec[150] == false) catch @panic("test failure");
3988		expect(vec[151] == false) catch @panic("test failure");
3989		expect(vec[152] == false) catch @panic("test failure");
3990		expect(vec[153] == false) catch @panic("test failure");
3991		expect(vec[154] == true) catch @panic("test failure");
3992		expect(vec[155] == false) catch @panic("test failure");
3993		expect(vec[156] == false) catch @panic("test failure");
3994		expect(vec[157] == false) catch @panic("test failure");
3995		expect(vec[158] == true) catch @panic("test failure");
3996		expect(vec[159] == true) catch @panic("test failure");
3997		expect(vec[160] == false) catch @panic("test failure");
3998		expect(vec[161] == true) catch @panic("test failure");
3999		expect(vec[162] == false) catch @panic("test failure");
4000		expect(vec[163] == false) catch @panic("test failure");
4001		expect(vec[164] == false) catch @panic("test failure");
4002		expect(vec[165] == true) catch @panic("test failure");
4003		expect(vec[166] == false) catch @panic("test failure");
4004		expect(vec[167] == true) catch @panic("test failure");
4005		expect(vec[168] == false) catch @panic("test failure");
4006		expect(vec[169] == false) catch @panic("test failure");
4007		expect(vec[170] == false) catch @panic("test failure");
4008		expect(vec[171] == false) catch @panic("test failure");
4009		expect(vec[172] == true) catch @panic("test failure");
4010		expect(vec[173] == true) catch @panic("test failure");
4011		expect(vec[174] == true) catch @panic("test failure");
4012		expect(vec[175] == true) catch @panic("test failure");
4013		expect(vec[176] == true) catch @panic("test failure");
4014		expect(vec[177] == true) catch @panic("test failure");
4015		expect(vec[178] == false) catch @panic("test failure");
4016		expect(vec[179] == true) catch @panic("test failure");
4017		expect(vec[180] == true) catch @panic("test failure");
4018		expect(vec[181] == false) catch @panic("test failure");
4019		expect(vec[182] == true) catch @panic("test failure");
4020		expect(vec[183] == false) catch @panic("test failure");
4021		expect(vec[184] == true) catch @panic("test failure");
4022		expect(vec[185] == false) catch @panic("test failure");
4023		expect(vec[186] == true) catch @panic("test failure");
4024		expect(vec[187] == false) catch @panic("test failure");
4025		expect(vec[188] == true) catch @panic("test failure");
4026		expect(vec[189] == false) catch @panic("test failure");
4027		expect(vec[190] == false) catch @panic("test failure");
4028		expect(vec[191] == false) catch @panic("test failure");
4029		expect(vec[192] == false) catch @panic("test failure");
4030		expect(vec[193] == true) catch @panic("test failure");
4031		expect(vec[194] == true) catch @panic("test failure");
4032		expect(vec[195] == true) catch @panic("test failure");
4033		expect(vec[196] == false) catch @panic("test failure");
4034		expect(vec[197] == false) catch @panic("test failure");
4035		expect(vec[198] == true) catch @panic("test failure");
4036		expect(vec[199] == false) catch @panic("test failure");
4037		expect(vec[200] == false) catch @panic("test failure");
4038		expect(vec[201] == true) catch @panic("test failure");
4039		expect(vec[202] == true) catch @panic("test failure");
4040		expect(vec[203] == false) catch @panic("test failure");
4041		expect(vec[204] == true) catch @panic("test failure");
4042		expect(vec[205] == false) catch @panic("test failure");
4043		expect(vec[206] == true) catch @panic("test failure");
4044		expect(vec[207] == false) catch @panic("test failure");
4045		expect(vec[208] == false) catch @panic("test failure");
4046		expect(vec[209] == false) catch @panic("test failure");
4047		expect(vec[210] == true) catch @panic("test failure");
4048		expect(vec[211] == true) catch @panic("test failure");
4049		expect(vec[212] == false) catch @panic("test failure");
4050		expect(vec[213] == false) catch @panic("test failure");
4051		expect(vec[214] == false) catch @panic("test failure");
4052		expect(vec[215] == true) catch @panic("test failure");
4053		expect(vec[216] == false) catch @panic("test failure");
4054		expect(vec[217] == true) catch @panic("test failure");
4055		expect(vec[218] == true) catch @panic("test failure");
4056		expect(vec[219] == true) catch @panic("test failure");
4057		expect(vec[220] == false) catch @panic("test failure");
4058		expect(vec[221] == true) catch @panic("test failure");
4059		expect(vec[222] == false) catch @panic("test failure");
4060		expect(vec[223] == true) catch @panic("test failure");
4061		expect(vec[224] == false) catch @panic("test failure");
4062		expect(vec[225] == false) catch @panic("test failure");
4063		expect(vec[226] == false) catch @panic("test failure");
4064		expect(vec[227] == true) catch @panic("test failure");
4065		expect(vec[228] == true) catch @panic("test failure");
4066		expect(vec[229] == false) catch @panic("test failure");
4067		expect(vec[230] == false) catch @panic("test failure");
4068		expect(vec[231] == false) catch @panic("test failure");
4069		expect(vec[232] == false) catch @panic("test failure");
4070		expect(vec[233] == false) catch @panic("test failure");
4071		expect(vec[234] == true) catch @panic("test failure");
4072		expect(vec[235] == false) catch @panic("test failure");
4073		expect(vec[236] == false) catch @panic("test failure");
4074		expect(vec[237] == false) catch @panic("test failure");
4075		expect(vec[238] == true) catch @panic("test failure");
4076		expect(vec[239] == false) catch @panic("test failure");
4077		expect(vec[240] == true) catch @panic("test failure");
4078		expect(vec[241] == true) catch @panic("test failure");
4079		expect(vec[242] == true) catch @panic("test failure");
4080		expect(vec[243] == false) catch @panic("test failure");
4081		expect(vec[244] == false) catch @panic("test failure");
4082		expect(vec[245] == true) catch @panic("test failure");
4083		expect(vec[246] == false) catch @panic("test failure");
4084		expect(vec[247] == false) catch @panic("test failure");
4085		expect(vec[248] == false) catch @panic("test failure");
4086		expect(vec[249] == true) catch @panic("test failure");
4087		expect(vec[250] == false) catch @panic("test failure");
4088		expect(vec[251] == false) catch @panic("test failure");
4089		expect(vec[252] == true) catch @panic("test failure");
4090		expect(vec[253] == true) catch @panic("test failure");
4091		expect(vec[254] == true) catch @panic("test failure");
4092		expect(vec[255] == true) catch @panic("test failure");
4093		}
4094
4095		export fn zig_vector_512_bool(vec: Vector512Bool) void {
4096		expect(vec[0] == false) catch @panic("test failure");
4097		expect(vec[1] == true) catch @panic("test failure");
4098		expect(vec[2] == true) catch @panic("test failure");
4099		expect(vec[3] == false) catch @panic("test failure");
4100		expect(vec[4] == true) catch @panic("test failure");
4101		expect(vec[5] == false) catch @panic("test failure");
4102		expect(vec[6] == true) catch @panic("test failure");
4103		expect(vec[7] == false) catch @panic("test failure");
4104		expect(vec[8] == false) catch @panic("test failure");
4105		expect(vec[9] == false) catch @panic("test failure");
4106		expect(vec[10] == false) catch @panic("test failure");
4107		expect(vec[11] == false) catch @panic("test failure");
4108		expect(vec[12] == true) catch @panic("test failure");
4109		expect(vec[13] == false) catch @panic("test failure");
4110		expect(vec[14] == true) catch @panic("test failure");
4111		expect(vec[15] == false) catch @panic("test failure");
4112		expect(vec[16] == false) catch @panic("test failure");
4113		expect(vec[17] == false) catch @panic("test failure");
4114		expect(vec[18] == true) catch @panic("test failure");
4115		expect(vec[19] == true) catch @panic("test failure");
4116		expect(vec[20] == true) catch @panic("test failure");
4117		expect(vec[21] == true) catch @panic("test failure");
4118		expect(vec[22] == false) catch @panic("test failure");
4119		expect(vec[23] == false) catch @panic("test failure");
4120		expect(vec[24] == false) catch @panic("test failure");
4121		expect(vec[25] == true) catch @panic("test failure");
4122		expect(vec[26] == true) catch @panic("test failure");
4123		expect(vec[27] == false) catch @panic("test failure");
4124		expect(vec[28] == true) catch @panic("test failure");
4125		expect(vec[29] == true) catch @panic("test failure");
4126		expect(vec[30] == false) catch @panic("test failure");
4127		expect(vec[31] == false) catch @panic("test failure");
4128		expect(vec[32] == true) catch @panic("test failure");
4129		expect(vec[33] == true) catch @panic("test failure");
4130		expect(vec[34] == false) catch @panic("test failure");
4131		expect(vec[35] == false) catch @panic("test failure");
4132		expect(vec[36] == false) catch @panic("test failure");
4133		expect(vec[37] == false) catch @panic("test failure");
4134		expect(vec[38] == false) catch @panic("test failure");
4135		expect(vec[39] == false) catch @panic("test failure");
4136		expect(vec[40] == false) catch @panic("test failure");
4137		expect(vec[41] == true) catch @panic("test failure");
4138		expect(vec[42] == true) catch @panic("test failure");
4139		expect(vec[43] == true) catch @panic("test failure");
4140		expect(vec[44] == false) catch @panic("test failure");
4141		expect(vec[45] == true) catch @panic("test failure");
4142		expect(vec[46] == true) catch @panic("test failure");
4143		expect(vec[47] == true) catch @panic("test failure");
4144		expect(vec[48] == true) catch @panic("test failure");
4145		expect(vec[49] == true) catch @panic("test failure");
4146		expect(vec[50] == false) catch @panic("test failure");
4147		expect(vec[51] == true) catch @panic("test failure");
4148		expect(vec[52] == true) catch @panic("test failure");
4149		expect(vec[53] == true) catch @panic("test failure");
4150		expect(vec[54] == false) catch @panic("test failure");
4151		expect(vec[55] == true) catch @panic("test failure");
4152		expect(vec[56] == false) catch @panic("test failure");
4153		expect(vec[57] == false) catch @panic("test failure");
4154		expect(vec[58] == true) catch @panic("test failure");
4155		expect(vec[59] == false) catch @panic("test failure");
4156		expect(vec[60] == true) catch @panic("test failure");
4157		expect(vec[61] == true) catch @panic("test failure");
4158		expect(vec[62] == false) catch @panic("test failure");
4159		expect(vec[63] == false) catch @panic("test failure");
4160		expect(vec[64] == false) catch @panic("test failure");
4161		expect(vec[65] == true) catch @panic("test failure");
4162		expect(vec[66] == true) catch @panic("test failure");
4163		expect(vec[67] == true) catch @panic("test failure");
4164		expect(vec[68] == true) catch @panic("test failure");
4165		expect(vec[69] == false) catch @panic("test failure");
4166		expect(vec[70] == false) catch @panic("test failure");
4167		expect(vec[71] == true) catch @panic("test failure");
4168		expect(vec[72] == true) catch @panic("test failure");
4169		expect(vec[73] == false) catch @panic("test failure");
4170		expect(vec[74] == true) catch @panic("test failure");
4171		expect(vec[75] == true) catch @panic("test failure");
4172		expect(vec[76] == false) catch @panic("test failure");
4173		expect(vec[77] == false) catch @panic("test failure");
4174		expect(vec[78] == true) catch @panic("test failure");
4175		expect(vec[79] == false) catch @panic("test failure");
4176		expect(vec[80] == false) catch @panic("test failure");
4177		expect(vec[81] == false) catch @panic("test failure");
4178		expect(vec[82] == true) catch @panic("test failure");
4179		expect(vec[83] == true) catch @panic("test failure");
4180		expect(vec[84] == true) catch @panic("test failure");
4181		expect(vec[85] == false) catch @panic("test failure");
4182		expect(vec[86] == false) catch @panic("test failure");
4183		expect(vec[87] == true) catch @panic("test failure");
4184		expect(vec[88] == false) catch @panic("test failure");
4185		expect(vec[89] == true) catch @panic("test failure");
4186		expect(vec[90] == false) catch @panic("test failure");
4187		expect(vec[91] == false) catch @panic("test failure");
4188		expect(vec[92] == true) catch @panic("test failure");
4189		expect(vec[93] == false) catch @panic("test failure");
4190		expect(vec[94] == false) catch @panic("test failure");
4191		expect(vec[95] == true) catch @panic("test failure");
4192		expect(vec[96] == true) catch @panic("test failure");
4193		expect(vec[97] == false) catch @panic("test failure");
4194		expect(vec[98] == false) catch @panic("test failure");
4195		expect(vec[99] == false) catch @panic("test failure");
4196		expect(vec[100] == false) catch @panic("test failure");
4197		expect(vec[101] == true) catch @panic("test failure");
4198		expect(vec[102] == false) catch @panic("test failure");
4199		expect(vec[103] == false) catch @panic("test failure");
4200		expect(vec[104] == false) catch @panic("test failure");
4201		expect(vec[105] == false) catch @panic("test failure");
4202		expect(vec[106] == false) catch @panic("test failure");
4203		expect(vec[107] == false) catch @panic("test failure");
4204		expect(vec[108] == true) catch @panic("test failure");
4205		expect(vec[109] == true) catch @panic("test failure");
4206		expect(vec[110] == true) catch @panic("test failure");
4207		expect(vec[111] == true) catch @panic("test failure");
4208		expect(vec[112] == true) catch @panic("test failure");
4209		expect(vec[113] == false) catch @panic("test failure");
4210		expect(vec[114] == false) catch @panic("test failure");
4211		expect(vec[115] == false) catch @panic("test failure");
4212		expect(vec[116] == false) catch @panic("test failure");
4213		expect(vec[117] == true) catch @panic("test failure");
4214		expect(vec[118] == true) catch @panic("test failure");
4215		expect(vec[119] == false) catch @panic("test failure");
4216		expect(vec[120] == true) catch @panic("test failure");
4217		expect(vec[121] == true) catch @panic("test failure");
4218		expect(vec[122] == false) catch @panic("test failure");
4219		expect(vec[123] == false) catch @panic("test failure");
4220		expect(vec[124] == true) catch @panic("test failure");
4221		expect(vec[125] == false) catch @panic("test failure");
4222		expect(vec[126] == false) catch @panic("test failure");
4223		expect(vec[127] == false) catch @panic("test failure");
4224		expect(vec[128] == false) catch @panic("test failure");
4225		expect(vec[129] == true) catch @panic("test failure");
4226		expect(vec[130] == true) catch @panic("test failure");
4227		expect(vec[131] == true) catch @panic("test failure");
4228		expect(vec[132] == true) catch @panic("test failure");
4229		expect(vec[133] == false) catch @panic("test failure");
4230		expect(vec[134] == false) catch @panic("test failure");
4231		expect(vec[135] == false) catch @panic("test failure");
4232		expect(vec[136] == false) catch @panic("test failure");
4233		expect(vec[137] == true) catch @panic("test failure");
4234		expect(vec[138] == false) catch @panic("test failure");
4235		expect(vec[139] == false) catch @panic("test failure");
4236		expect(vec[140] == false) catch @panic("test failure");
4237		expect(vec[141] == false) catch @panic("test failure");
4238		expect(vec[142] == true) catch @panic("test failure");
4239		expect(vec[143] == true) catch @panic("test failure");
4240		expect(vec[144] == false) catch @panic("test failure");
4241		expect(vec[145] == true) catch @panic("test failure");
4242		expect(vec[146] == false) catch @panic("test failure");
4243		expect(vec[147] == true) catch @panic("test failure");
4244		expect(vec[148] == false) catch @panic("test failure");
4245		expect(vec[149] == false) catch @panic("test failure");
4246		expect(vec[150] == true) catch @panic("test failure");
4247		expect(vec[151] == true) catch @panic("test failure");
4248		expect(vec[152] == false) catch @panic("test failure");
4249		expect(vec[153] == true) catch @panic("test failure");
4250		expect(vec[154] == true) catch @panic("test failure");
4251		expect(vec[155] == false) catch @panic("test failure");
4252		expect(vec[156] == false) catch @panic("test failure");
4253		expect(vec[157] == false) catch @panic("test failure");
4254		expect(vec[158] == true) catch @panic("test failure");
4255		expect(vec[159] == false) catch @panic("test failure");
4256		expect(vec[160] == false) catch @panic("test failure");
4257		expect(vec[161] == false) catch @panic("test failure");
4258		expect(vec[162] == false) catch @panic("test failure");
4259		expect(vec[163] == true) catch @panic("test failure");
4260		expect(vec[164] == true) catch @panic("test failure");
4261		expect(vec[165] == false) catch @panic("test failure");
4262		expect(vec[166] == false) catch @panic("test failure");
4263		expect(vec[167] == true) catch @panic("test failure");
4264		expect(vec[168] == false) catch @panic("test failure");
4265		expect(vec[169] == true) catch @panic("test failure");
4266		expect(vec[170] == true) catch @panic("test failure");
4267		expect(vec[171] == false) catch @panic("test failure");
4268		expect(vec[172] == false) catch @panic("test failure");
4269		expect(vec[173] == false) catch @panic("test failure");
4270		expect(vec[174] == false) catch @panic("test failure");
4271		expect(vec[175] == false) catch @panic("test failure");
4272		expect(vec[176] == false) catch @panic("test failure");
4273		expect(vec[177] == true) catch @panic("test failure");
4274		expect(vec[178] == false) catch @panic("test failure");
4275		expect(vec[179] == false) catch @panic("test failure");
4276		expect(vec[180] == false) catch @panic("test failure");
4277		expect(vec[181] == false) catch @panic("test failure");
4278		expect(vec[182] == false) catch @panic("test failure");
4279		expect(vec[183] == false) catch @panic("test failure");
4280		expect(vec[184] == true) catch @panic("test failure");
4281		expect(vec[185] == false) catch @panic("test failure");
4282		expect(vec[186] == false) catch @panic("test failure");
4283		expect(vec[187] == false) catch @panic("test failure");
4284		expect(vec[188] == false) catch @panic("test failure");
4285		expect(vec[189] == true) catch @panic("test failure");
4286		expect(vec[190] == false) catch @panic("test failure");
4287		expect(vec[191] == false) catch @panic("test failure");
4288		expect(vec[192] == false) catch @panic("test failure");
4289		expect(vec[193] == false) catch @panic("test failure");
4290		expect(vec[194] == false) catch @panic("test failure");
4291		expect(vec[195] == false) catch @panic("test failure");
4292		expect(vec[196] == true) catch @panic("test failure");
4293		expect(vec[197] == true) catch @panic("test failure");
4294		expect(vec[198] == true) catch @panic("test failure");
4295		expect(vec[199] == false) catch @panic("test failure");
4296		expect(vec[200] == true) catch @panic("test failure");
4297		expect(vec[201] == true) catch @panic("test failure");
4298		expect(vec[202] == false) catch @panic("test failure");
4299		expect(vec[203] == false) catch @panic("test failure");
4300		expect(vec[204] == false) catch @panic("test failure");
4301		expect(vec[205] == false) catch @panic("test failure");
4302		expect(vec[206] == false) catch @panic("test failure");
4303		expect(vec[207] == true) catch @panic("test failure");
4304		expect(vec[208] == true) catch @panic("test failure");
4305		expect(vec[209] == false) catch @panic("test failure");
4306		expect(vec[210] == false) catch @panic("test failure");
4307		expect(vec[211] == false) catch @panic("test failure");
4308		expect(vec[212] == true) catch @panic("test failure");
4309		expect(vec[213] == false) catch @panic("test failure");
4310		expect(vec[214] == false) catch @panic("test failure");
4311		expect(vec[215] == true) catch @panic("test failure");
4312		expect(vec[216] == true) catch @panic("test failure");
4313		expect(vec[217] == true) catch @panic("test failure");
4314		expect(vec[218] == false) catch @panic("test failure");
4315		expect(vec[219] == false) catch @panic("test failure");
4316		expect(vec[220] == true) catch @panic("test failure");
4317		expect(vec[221] == false) catch @panic("test failure");
4318		expect(vec[222] == true) catch @panic("test failure");
4319		expect(vec[223] == true) catch @panic("test failure");
4320		expect(vec[224] == true) catch @panic("test failure");
4321		expect(vec[225] == true) catch @panic("test failure");
4322		expect(vec[226] == false) catch @panic("test failure");
4323		expect(vec[227] == true) catch @panic("test failure");
4324		expect(vec[228] == false) catch @panic("test failure");
4325		expect(vec[229] == false) catch @panic("test failure");
4326		expect(vec[230] == false) catch @panic("test failure");
4327		expect(vec[231] == true) catch @panic("test failure");
4328		expect(vec[232] == false) catch @panic("test failure");
4329		expect(vec[233] == false) catch @panic("test failure");
4330		expect(vec[234] == false) catch @panic("test failure");
4331		expect(vec[235] == false) catch @panic("test failure");
4332		expect(vec[236] == false) catch @panic("test failure");
4333		expect(vec[237] == false) catch @panic("test failure");
4334		expect(vec[238] == false) catch @panic("test failure");
4335		expect(vec[239] == true) catch @panic("test failure");
4336		expect(vec[240] == false) catch @panic("test failure");
4337		expect(vec[241] == false) catch @panic("test failure");
4338		expect(vec[242] == false) catch @panic("test failure");
4339		expect(vec[243] == true) catch @panic("test failure");
4340		expect(vec[244] == true) catch @panic("test failure");
4341		expect(vec[245] == true) catch @panic("test failure");
4342		expect(vec[246] == true) catch @panic("test failure");
4343		expect(vec[247] == false) catch @panic("test failure");
4344		expect(vec[248] == true) catch @panic("test failure");
4345		expect(vec[249] == true) catch @panic("test failure");
4346		expect(vec[250] == false) catch @panic("test failure");
4347		expect(vec[251] == false) catch @panic("test failure");
4348		expect(vec[252] == false) catch @panic("test failure");
4349		expect(vec[253] == true) catch @panic("test failure");
4350		expect(vec[254] == false) catch @panic("test failure");
4351		expect(vec[255] == false) catch @panic("test failure");
4352		expect(vec[256] == true) catch @panic("test failure");
4353		expect(vec[257] == true) catch @panic("test failure");
4354		expect(vec[258] == false) catch @panic("test failure");
4355		expect(vec[259] == true) catch @panic("test failure");
4356		expect(vec[260] == false) catch @panic("test failure");
4357		expect(vec[261] == true) catch @panic("test failure");
4358		expect(vec[262] == true) catch @panic("test failure");
4359		expect(vec[263] == false) catch @panic("test failure");
4360		expect(vec[264] == false) catch @panic("test failure");
4361		expect(vec[265] == false) catch @panic("test failure");
4362		expect(vec[266] == false) catch @panic("test failure");
4363		expect(vec[267] == true) catch @panic("test failure");
4364		expect(vec[268] == false) catch @panic("test failure");
4365		expect(vec[269] == true) catch @panic("test failure");
4366		expect(vec[270] == true) catch @panic("test failure");
4367		expect(vec[271] == false) catch @panic("test failure");
4368		expect(vec[272] == false) catch @panic("test failure");
4369		expect(vec[273] == true) catch @panic("test failure");
4370		expect(vec[274] == true) catch @panic("test failure");
4371		expect(vec[275] == true) catch @panic("test failure");
4372		expect(vec[276] == false) catch @panic("test failure");
4373		expect(vec[277] == true) catch @panic("test failure");
4374		expect(vec[278] == false) catch @panic("test failure");
4375		expect(vec[279] == false) catch @panic("test failure");
4376		expect(vec[280] == true) catch @panic("test failure");
4377		expect(vec[281] == true) catch @panic("test failure");
4378		expect(vec[282] == false) catch @panic("test failure");
4379		expect(vec[283] == true) catch @panic("test failure");
4380		expect(vec[284] == false) catch @panic("test failure");
4381		expect(vec[285] == true) catch @panic("test failure");
4382		expect(vec[286] == true) catch @panic("test failure");
4383		expect(vec[287] == true) catch @panic("test failure");
4384		expect(vec[288] == true) catch @panic("test failure");
4385		expect(vec[289] == true) catch @panic("test failure");
4386		expect(vec[290] == true) catch @panic("test failure");
4387		expect(vec[291] == true) catch @panic("test failure");
4388		expect(vec[292] == true) catch @panic("test failure");
4389		expect(vec[293] == true) catch @panic("test failure");
4390		expect(vec[294] == true) catch @panic("test failure");
4391		expect(vec[295] == false) catch @panic("test failure");
4392		expect(vec[296] == true) catch @panic("test failure");
4393		expect(vec[297] == false) catch @panic("test failure");
4394		expect(vec[298] == true) catch @panic("test failure");
4395		expect(vec[299] == false) catch @panic("test failure");
4396		expect(vec[300] == true) catch @panic("test failure");
4397		expect(vec[301] == true) catch @panic("test failure");
4398		expect(vec[302] == false) catch @panic("test failure");
4399		expect(vec[303] == true) catch @panic("test failure");
4400		expect(vec[304] == false) catch @panic("test failure");
4401		expect(vec[305] == true) catch @panic("test failure");
4402		expect(vec[306] == false) catch @panic("test failure");
4403		expect(vec[307] == true) catch @panic("test failure");
4404		expect(vec[308] == true) catch @panic("test failure");
4405		expect(vec[309] == false) catch @panic("test failure");
4406		expect(vec[310] == true) catch @panic("test failure");
4407		expect(vec[311] == true) catch @panic("test failure");
4408		expect(vec[312] == true) catch @panic("test failure");
4409		expect(vec[313] == false) catch @panic("test failure");
4410		expect(vec[314] == false) catch @panic("test failure");
4411		expect(vec[315] == false) catch @panic("test failure");
4412		expect(vec[316] == false) catch @panic("test failure");
4413		expect(vec[317] == true) catch @panic("test failure");
4414		expect(vec[318] == true) catch @panic("test failure");
4415		expect(vec[319] == true) catch @panic("test failure");
4416		expect(vec[320] == true) catch @panic("test failure");
4417		expect(vec[321] == true) catch @panic("test failure");
4418		expect(vec[322] == true) catch @panic("test failure");
4419		expect(vec[323] == true) catch @panic("test failure");
4420		expect(vec[324] == true) catch @panic("test failure");
4421		expect(vec[325] == true) catch @panic("test failure");
4422		expect(vec[326] == false) catch @panic("test failure");
4423		expect(vec[327] == true) catch @panic("test failure");
4424		expect(vec[328] == false) catch @panic("test failure");
4425		expect(vec[329] == false) catch @panic("test failure");
4426		expect(vec[330] == true) catch @panic("test failure");
4427		expect(vec[331] == false) catch @panic("test failure");
4428		expect(vec[332] == false) catch @panic("test failure");
4429		expect(vec[333] == false) catch @panic("test failure");
4430		expect(vec[334] == false) catch @panic("test failure");
4431		expect(vec[335] == false) catch @panic("test failure");
4432		expect(vec[336] == false) catch @panic("test failure");
4433		expect(vec[337] == false) catch @panic("test failure");
4434		expect(vec[338] == false) catch @panic("test failure");
4435		expect(vec[339] == false) catch @panic("test failure");
4436		expect(vec[340] == false) catch @panic("test failure");
4437		expect(vec[341] == false) catch @panic("test failure");
4438		expect(vec[342] == true) catch @panic("test failure");
4439		expect(vec[343] == true) catch @panic("test failure");
4440		expect(vec[344] == false) catch @panic("test failure");
4441		expect(vec[345] == false) catch @panic("test failure");
4442		expect(vec[346] == false) catch @panic("test failure");
4443		expect(vec[347] == false) catch @panic("test failure");
4444		expect(vec[348] == false) catch @panic("test failure");
4445		expect(vec[349] == true) catch @panic("test failure");
4446		expect(vec[350] == true) catch @panic("test failure");
4447		expect(vec[351] == true) catch @panic("test failure");
4448		expect(vec[352] == true) catch @panic("test failure");
4449		expect(vec[353] == false) catch @panic("test failure");
4450		expect(vec[354] == false) catch @panic("test failure");
4451		expect(vec[355] == false) catch @panic("test failure");
4452		expect(vec[356] == false) catch @panic("test failure");
4453		expect(vec[357] == true) catch @panic("test failure");
4454		expect(vec[358] == true) catch @panic("test failure");
4455		expect(vec[359] == false) catch @panic("test failure");
4456		expect(vec[360] == false) catch @panic("test failure");
4457		expect(vec[361] == false) catch @panic("test failure");
4458		expect(vec[362] == true) catch @panic("test failure");
4459		expect(vec[363] == true) catch @panic("test failure");
4460		expect(vec[364] == false) catch @panic("test failure");
4461		expect(vec[365] == false) catch @panic("test failure");
4462		expect(vec[366] == false) catch @panic("test failure");
4463		expect(vec[367] == false) catch @panic("test failure");
4464		expect(vec[368] == false) catch @panic("test failure");
4465		expect(vec[369] == true) catch @panic("test failure");
4466		expect(vec[370] == true) catch @panic("test failure");
4467		expect(vec[371] == false) catch @panic("test failure");
4468		expect(vec[372] == true) catch @panic("test failure");
4469		expect(vec[373] == true) catch @panic("test failure");
4470		expect(vec[374] == false) catch @panic("test failure");
4471		expect(vec[375] == true) catch @panic("test failure");
4472		expect(vec[376] == true) catch @panic("test failure");
4473		expect(vec[377] == false) catch @panic("test failure");
4474		expect(vec[378] == true) catch @panic("test failure");
4475		expect(vec[379] == true) catch @panic("test failure");
4476		expect(vec[380] == false) catch @panic("test failure");
4477		expect(vec[381] == true) catch @panic("test failure");
4478		expect(vec[382] == true) catch @panic("test failure");
4479		expect(vec[383] == false) catch @panic("test failure");
4480		expect(vec[384] == true) catch @panic("test failure");
4481		expect(vec[385] == false) catch @panic("test failure");
4482		expect(vec[386] == true) catch @panic("test failure");
4483		expect(vec[387] == true) catch @panic("test failure");
4484		expect(vec[388] == true) catch @panic("test failure");
4485		expect(vec[389] == true) catch @panic("test failure");
4486		expect(vec[390] == false) catch @panic("test failure");
4487		expect(vec[391] == false) catch @panic("test failure");
4488		expect(vec[392] == false) catch @panic("test failure");
4489		expect(vec[393] == true) catch @panic("test failure");
4490		expect(vec[394] == true) catch @panic("test failure");
4491		expect(vec[395] == true) catch @panic("test failure");
4492		expect(vec[396] == true) catch @panic("test failure");
4493		expect(vec[397] == false) catch @panic("test failure");
4494		expect(vec[398] == true) catch @panic("test failure");
4495		expect(vec[399] == true) catch @panic("test failure");
4496		expect(vec[400] == true) catch @panic("test failure");
4497		expect(vec[401] == false) catch @panic("test failure");
4498		expect(vec[402] == false) catch @panic("test failure");
4499		expect(vec[403] == true) catch @panic("test failure");
4500		expect(vec[404] == false) catch @panic("test failure");
4501		expect(vec[405] == false) catch @panic("test failure");
4502		expect(vec[406] == false) catch @panic("test failure");
4503		expect(vec[407] == true) catch @panic("test failure");
4504		expect(vec[408] == true) catch @panic("test failure");
4505		expect(vec[409] == true) catch @panic("test failure");
4506		expect(vec[410] == false) catch @panic("test failure");
4507		expect(vec[411] == true) catch @panic("test failure");
4508		expect(vec[412] == false) catch @panic("test failure");
4509		expect(vec[413] == false) catch @panic("test failure");
4510		expect(vec[414] == false) catch @panic("test failure");
4511		expect(vec[415] == true) catch @panic("test failure");
4512		expect(vec[416] == false) catch @panic("test failure");
4513		expect(vec[417] == false) catch @panic("test failure");
4514		expect(vec[418] == true) catch @panic("test failure");
4515		expect(vec[419] == true) catch @panic("test failure");
4516		expect(vec[420] == true) catch @panic("test failure");
4517		expect(vec[421] == true) catch @panic("test failure");
4518		expect(vec[422] == false) catch @panic("test failure");
4519		expect(vec[423] == true) catch @panic("test failure");
4520		expect(vec[424] == true) catch @panic("test failure");
4521		expect(vec[425] == false) catch @panic("test failure");
4522		expect(vec[426] == false) catch @panic("test failure");
4523		expect(vec[427] == false) catch @panic("test failure");
4524		expect(vec[428] == true) catch @panic("test failure");
4525		expect(vec[429] == false) catch @panic("test failure");
4526		expect(vec[430] == true) catch @panic("test failure");
4527		expect(vec[431] == true) catch @panic("test failure");
4528		expect(vec[432] == false) catch @panic("test failure");
4529		expect(vec[433] == false) catch @panic("test failure");
4530		expect(vec[434] == false) catch @panic("test failure");
4531		expect(vec[435] == false) catch @panic("test failure");
4532		expect(vec[436] == true) catch @panic("test failure");
4533		expect(vec[437] == false) catch @panic("test failure");
4534		expect(vec[438] == true) catch @panic("test failure");
4535		expect(vec[439] == false) catch @panic("test failure");
4536		expect(vec[440] == false) catch @panic("test failure");
4537		expect(vec[441] == false) catch @panic("test failure");
4538		expect(vec[442] == false) catch @panic("test failure");
4539		expect(vec[443] == true) catch @panic("test failure");
4540		expect(vec[444] == false) catch @panic("test failure");
4541		expect(vec[445] == false) catch @panic("test failure");
4542		expect(vec[446] == true) catch @panic("test failure");
4543		expect(vec[447] == true) catch @panic("test failure");
4544		expect(vec[448] == true) catch @panic("test failure");
4545		expect(vec[449] == false) catch @panic("test failure");
4546		expect(vec[450] == true) catch @panic("test failure");
4547		expect(vec[451] == true) catch @panic("test failure");
4548		expect(vec[452] == false) catch @panic("test failure");
4549		expect(vec[453] == true) catch @panic("test failure");
4550		expect(vec[454] == false) catch @panic("test failure");
4551		expect(vec[455] == true) catch @panic("test failure");
4552		expect(vec[456] == false) catch @panic("test failure");
4553		expect(vec[457] == false) catch @panic("test failure");
4554		expect(vec[458] == false) catch @panic("test failure");
4555		expect(vec[459] == true) catch @panic("test failure");
4556		expect(vec[460] == false) catch @panic("test failure");
4557		expect(vec[461] == false) catch @panic("test failure");
4558		expect(vec[462] == false) catch @panic("test failure");
4559		expect(vec[463] == true) catch @panic("test failure");
4560		expect(vec[464] == true) catch @panic("test failure");
4561		expect(vec[465] == true) catch @panic("test failure");
4562		expect(vec[466] == true) catch @panic("test failure");
4563		expect(vec[467] == true) catch @panic("test failure");
4564		expect(vec[468] == false) catch @panic("test failure");
4565		expect(vec[469] == false) catch @panic("test failure");
4566		expect(vec[470] == false) catch @panic("test failure");
4567		expect(vec[471] == false) catch @panic("test failure");
4568		expect(vec[472] == false) catch @panic("test failure");
4569		expect(vec[473] == false) catch @panic("test failure");
4570		expect(vec[474] == true) catch @panic("test failure");
4571		expect(vec[475] == true) catch @panic("test failure");
4572		expect(vec[476] == true) catch @panic("test failure");
4573		expect(vec[477] == true) catch @panic("test failure");
4574		expect(vec[478] == true) catch @panic("test failure");
4575		expect(vec[479] == false) catch @panic("test failure");
4576		expect(vec[480] == true) catch @panic("test failure");
4577		expect(vec[481] == true) catch @panic("test failure");
4578		expect(vec[482] == false) catch @panic("test failure");
4579		expect(vec[483] == true) catch @panic("test failure");
4580		expect(vec[484] == false) catch @panic("test failure");
4581		expect(vec[485] == true) catch @panic("test failure");
4582		expect(vec[486] == false) catch @panic("test failure");
4583		expect(vec[487] == true) catch @panic("test failure");
4584		expect(vec[488] == false) catch @panic("test failure");
4585		expect(vec[489] == false) catch @panic("test failure");
4586		expect(vec[490] == false) catch @panic("test failure");
4587		expect(vec[491] == true) catch @panic("test failure");
4588		expect(vec[492] == false) catch @panic("test failure");
4589		expect(vec[493] == false) catch @panic("test failure");
4590		expect(vec[494] == false) catch @panic("test failure");
4591		expect(vec[495] == true) catch @panic("test failure");
4592		expect(vec[496] == true) catch @panic("test failure");
4593		expect(vec[497] == false) catch @panic("test failure");
4594		expect(vec[498] == false) catch @panic("test failure");
4595		expect(vec[499] == true) catch @panic("test failure");
4596		expect(vec[500] == false) catch @panic("test failure");
4597		expect(vec[501] == true) catch @panic("test failure");
4598		expect(vec[502] == false) catch @panic("test failure");
4599		expect(vec[503] == false) catch @panic("test failure");
4600		expect(vec[504] == false) catch @panic("test failure");
4601		expect(vec[505] == true) catch @panic("test failure");
4602		expect(vec[506] == true) catch @panic("test failure");
4603		expect(vec[507] == true) catch @panic("test failure");
4604		expect(vec[508] == true) catch @panic("test failure");
4605		expect(vec[509] == false) catch @panic("test failure");
4606		expect(vec[510] == false) catch @panic("test failure");
4607		expect(vec[511] == true) catch @panic("test failure");
4608		}
4609
4610		export fn zig_ret_vector_2_bool() Vector2Bool {
4611		return .{
4612		false,
4613		false,
4614		};
4615		}
4616
4617		export fn zig_ret_vector_4_bool() Vector4Bool {
4618		return .{
4619		false,
4620		true,
4621		true,
4622		true,
4623		};
4624		}
4625
4626		export fn zig_ret_vector_8_bool() Vector8Bool {
4627		return .{
4628		false,
4629		false,
4630		false,
4631		false,
4632		true,
4633		false,
4634		false,
4635		false,
4636		};
4637		}
4638
4639		export fn zig_ret_vector_16_bool() Vector16Bool {
4640		return .{
4641		false,
4642		true,
4643		false,
4644		false,
4645		false,
4646		true,
4647		false,
4648		false,
4649		true,
4650		false,
4651		false,
4652		false,
4653		false,
4654		true,
4655		false,
4656		false,
4657		};
4658		}
4659
4660		export fn zig_ret_vector_32_bool() Vector32Bool {
4661		return .{
4662		false,
4663		true,
4664		false,
4665		false,
4666		true,
4667		false,
4668		true,
4669		true,
4670		true,
4671		true,
4672		true,
4673		true,
4674		false,
4675		false,
4676		false,
4677		false,
4678		false,
4679		false,
4680		true,
4681		true,
4682		true,
4683		false,
4684		true,
4685		false,
4686		true,
4687		false,
4688		false,
4689		true,
4690		false,
4691		false,
4692		true,
4693		true,
4694		};
4695		}
4696
4697		export fn zig_ret_vector_64_bool() Vector64Bool {
4698		return .{
4699		true,
4700		false,
4701		true,
4702		false,
4703		false,
4704		true,
4705		false,
4706		true,
4707		true,
4708		false,
4709		true,
4710		false,
4711		true,
4712		false,
4713		false,
4714		true,
4715		false,
4716		false,
4717		true,
4718		true,
4719		false,
4720		false,
4721		true,
4722		false,
4723		false,
4724		true,
4725		true,
4726		true,
4727		true,
4728		true,
4729		false,
4730		false,
4731		true,
4732		true,
4733		true,
4734		true,
4735		false,
4736		true,
4737		false,
4738		true,
4739		true,
4740		true,
4741		true,
4742		true,
4743		false,
4744		false,
4745		false,
4746		true,
4747		true,
4748		true,
4749		false,
4750		true,
4751		true,
4752		true,
4753		false,
4754		false,
4755		false,
4756		true,
4757		false,
4758		false,
4759		true,
4760		false,
4761		true,
4762		false,
4763		};
4764		}
4765
4766		export fn zig_ret_vector_128_bool() Vector128Bool {
	960	_ = struct {
	961	export fn zig_ret_vector_128_bool() @Vector(128, bool) {
4767	962	return .{
4768	963	true,
4769	964	true,
...	...	@@ -4895,8 +1090,416 @@ comptime {
4895	1090	true,
4896	1091	};
4897	1092	}
	1093	export fn zig_vector_128_bool(vec: @Vector(128, bool)) void {
	1094	expect(vec[0] == true) catch @panic("test failure");
	1095	expect(vec[1] == true) catch @panic("test failure");
	1096	expect(vec[2] == false) catch @panic("test failure");
	1097	expect(vec[3] == true) catch @panic("test failure");
	1098	expect(vec[4] == true) catch @panic("test failure");
	1099	expect(vec[5] == false) catch @panic("test failure");
	1100	expect(vec[6] == false) catch @panic("test failure");
	1101	expect(vec[7] == true) catch @panic("test failure");
	1102	expect(vec[8] == true) catch @panic("test failure");
	1103	expect(vec[9] == true) catch @panic("test failure");
	1104	expect(vec[10] == true) catch @panic("test failure");
	1105	expect(vec[11] == true) catch @panic("test failure");
	1106	expect(vec[12] == false) catch @panic("test failure");
	1107	expect(vec[13] == false) catch @panic("test failure");
	1108	expect(vec[14] == false) catch @panic("test failure");
	1109	expect(vec[15] == true) catch @panic("test failure");
	1110	expect(vec[16] == false) catch @panic("test failure");
	1111	expect(vec[17] == true) catch @panic("test failure");
	1112	expect(vec[18] == false) catch @panic("test failure");
	1113	expect(vec[19] == false) catch @panic("test failure");
	1114	expect(vec[20] == true) catch @panic("test failure");
	1115	expect(vec[21] == false) catch @panic("test failure");
	1116	expect(vec[22] == true) catch @panic("test failure");
	1117	expect(vec[23] == false) catch @panic("test failure");
	1118	expect(vec[24] == false) catch @panic("test failure");
	1119	expect(vec[25] == false) catch @panic("test failure");
	1120	expect(vec[26] == true) catch @panic("test failure");
	1121	expect(vec[27] == false) catch @panic("test failure");
	1122	expect(vec[28] == true) catch @panic("test failure");
	1123	expect(vec[29] == true) catch @panic("test failure");
	1124	expect(vec[30] == false) catch @panic("test failure");
	1125	expect(vec[31] == true) catch @panic("test failure");
	1126	expect(vec[32] == false) catch @panic("test failure");
	1127	expect(vec[33] == true) catch @panic("test failure");
	1128	expect(vec[34] == true) catch @panic("test failure");
	1129	expect(vec[35] == false) catch @panic("test failure");
	1130	expect(vec[36] == false) catch @panic("test failure");
	1131	expect(vec[37] == false) catch @panic("test failure");
	1132	expect(vec[38] == false) catch @panic("test failure");
	1133	expect(vec[39] == true) catch @panic("test failure");
	1134	expect(vec[40] == true) catch @panic("test failure");
	1135	expect(vec[41] == false) catch @panic("test failure");
	1136	expect(vec[42] == true) catch @panic("test failure");
	1137	expect(vec[43] == false) catch @panic("test failure");
	1138	expect(vec[44] == false) catch @panic("test failure");
	1139	expect(vec[45] == true) catch @panic("test failure");
	1140	expect(vec[46] == false) catch @panic("test failure");
	1141	expect(vec[47] == false) catch @panic("test failure");
	1142	expect(vec[48] == true) catch @panic("test failure");
	1143	expect(vec[49] == true) catch @panic("test failure");
	1144	expect(vec[50] == false) catch @panic("test failure");
	1145	expect(vec[51] == false) catch @panic("test failure");
	1146	expect(vec[52] == true) catch @panic("test failure");
	1147	expect(vec[53] == false) catch @panic("test failure");
	1148	expect(vec[54] == false) catch @panic("test failure");
	1149	expect(vec[55] == true) catch @panic("test failure");
	1150	expect(vec[56] == true) catch @panic("test failure");
	1151	expect(vec[57] == true) catch @panic("test failure");
	1152	expect(vec[58] == true) catch @panic("test failure");
	1153	expect(vec[59] == true) catch @panic("test failure");
	1154	expect(vec[60] == true) catch @panic("test failure");
	1155	expect(vec[61] == true) catch @panic("test failure");
	1156	expect(vec[62] == true) catch @panic("test failure");
	1157	expect(vec[63] == false) catch @panic("test failure");
	1158	expect(vec[64] == false) catch @panic("test failure");
	1159	expect(vec[65] == true) catch @panic("test failure");
	1160	expect(vec[66] == false) catch @panic("test failure");
	1161	expect(vec[67] == true) catch @panic("test failure");
	1162	expect(vec[68] == true) catch @panic("test failure");
	1163	expect(vec[69] == true) catch @panic("test failure");
	1164	expect(vec[70] == true) catch @panic("test failure");
	1165	expect(vec[71] == false) catch @panic("test failure");
	1166	expect(vec[72] == false) catch @panic("test failure");
	1167	expect(vec[73] == false) catch @panic("test failure");
	1168	expect(vec[74] == true) catch @panic("test failure");
	1169	expect(vec[75] == true) catch @panic("test failure");
	1170	expect(vec[76] == false) catch @panic("test failure");
	1171	expect(vec[77] == true) catch @panic("test failure");
	1172	expect(vec[78] == true) catch @panic("test failure");
	1173	expect(vec[79] == true) catch @panic("test failure");
	1174	expect(vec[80] == true) catch @panic("test failure");
	1175	expect(vec[81] == false) catch @panic("test failure");
	1176	expect(vec[82] == true) catch @panic("test failure");
	1177	expect(vec[83] == true) catch @panic("test failure");
	1178	expect(vec[84] == true) catch @panic("test failure");
	1179	expect(vec[85] == true) catch @panic("test failure");
	1180	expect(vec[86] == true) catch @panic("test failure");
	1181	expect(vec[87] == true) catch @panic("test failure");
	1182	expect(vec[88] == false) catch @panic("test failure");
	1183	expect(vec[89] == true) catch @panic("test failure");
	1184	expect(vec[90] == true) catch @panic("test failure");
	1185	expect(vec[91] == true) catch @panic("test failure");
	1186	expect(vec[92] == true) catch @panic("test failure");
	1187	expect(vec[93] == true) catch @panic("test failure");
	1188	expect(vec[94] == true) catch @panic("test failure");
	1189	expect(vec[95] == false) catch @panic("test failure");
	1190	expect(vec[96] == false) catch @panic("test failure");
	1191	expect(vec[97] == false) catch @panic("test failure");
	1192	expect(vec[98] == true) catch @panic("test failure");
	1193	expect(vec[99] == true) catch @panic("test failure");
	1194	expect(vec[100] == true) catch @panic("test failure");
	1195	expect(vec[101] == true) catch @panic("test failure");
	1196	expect(vec[102] == true) catch @panic("test failure");
	1197	expect(vec[103] == true) catch @panic("test failure");
	1198	expect(vec[104] == true) catch @panic("test failure");
	1199	expect(vec[105] == false) catch @panic("test failure");
	1200	expect(vec[106] == false) catch @panic("test failure");
	1201	expect(vec[107] == false) catch @panic("test failure");
	1202	expect(vec[108] == false) catch @panic("test failure");
	1203	expect(vec[109] == false) catch @panic("test failure");
	1204	expect(vec[110] == true) catch @panic("test failure");
	1205	expect(vec[111] == true) catch @panic("test failure");
	1206	expect(vec[112] == true) catch @panic("test failure");
	1207	expect(vec[113] == false) catch @panic("test failure");
	1208	expect(vec[114] == false) catch @panic("test failure");
	1209	expect(vec[115] == false) catch @panic("test failure");
	1210	expect(vec[116] == false) catch @panic("test failure");
	1211	expect(vec[117] == false) catch @panic("test failure");
	1212	expect(vec[118] == true) catch @panic("test failure");
	1213	expect(vec[119] == false) catch @panic("test failure");
	1214	expect(vec[120] == false) catch @panic("test failure");
	1215	expect(vec[121] == false) catch @panic("test failure");
	1216	expect(vec[122] == false) catch @panic("test failure");
	1217	expect(vec[123] == true) catch @panic("test failure");
	1218	expect(vec[124] == true) catch @panic("test failure");
	1219	expect(vec[125] == false) catch @panic("test failure");
	1220	expect(vec[126] == true) catch @panic("test failure");
	1221	expect(vec[127] == false) catch @panic("test failure");
	1222	}
	1223	};
	1224	}
	1225	}
	1226
	1227	extern fn c_ret_vector_128_bool() @Vector(128, bool);
	1228	extern fn c_vector_128_bool(@Vector(128, bool)) void;
	1229	extern fn c_test_vector_128_bool() void;
	1230
	1231	test "@Vector(128, bool)" {
	1232	if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest;
	1233
	1234	const vec = c_ret_vector_128_bool();
	1235	try expect(vec[0] == false);
	1236	try expect(vec[1] == true);
	1237	try expect(vec[2] == true);
	1238	try expect(vec[3] == false);
	1239	try expect(vec[4] == true);
	1240	try expect(vec[5] == false);
	1241	try expect(vec[6] == false);
	1242	try expect(vec[7] == true);
	1243	try expect(vec[8] == true);
	1244	try expect(vec[9] == false);
	1245	try expect(vec[10] == true);
	1246	try expect(vec[11] == false);
	1247	try expect(vec[12] == false);
	1248	try expect(vec[13] == false);
	1249	try expect(vec[14] == true);
	1250	try expect(vec[15] == false);
	1251	try expect(vec[16] == true);
	1252	try expect(vec[17] == false);
	1253	try expect(vec[18] == false);
	1254	try expect(vec[19] == true);
	1255	try expect(vec[20] == false);
	1256	try expect(vec[21] == true);
	1257	try expect(vec[22] == false);
	1258	try expect(vec[23] == false);
	1259	try expect(vec[24] == false);
	1260	try expect(vec[25] == true);
	1261	try expect(vec[26] == true);
	1262	try expect(vec[27] == true);
	1263	try expect(vec[28] == false);
	1264	try expect(vec[29] == false);
	1265	try expect(vec[30] == false);
	1266	try expect(vec[31] == false);
	1267	try expect(vec[32] == true);
	1268	try expect(vec[33] == true);
	1269	try expect(vec[34] == true);
	1270	try expect(vec[35] == false);
	1271	try expect(vec[36] == true);
	1272	try expect(vec[37] == true);
	1273	try expect(vec[38] == false);
	1274	try expect(vec[39] == false);
	1275	try expect(vec[40] == false);
	1276	try expect(vec[41] == false);
	1277	try expect(vec[42] == true);
	1278	try expect(vec[43] == true);
	1279	try expect(vec[44] == true);
	1280	try expect(vec[45] == false);
	1281	try expect(vec[46] == false);
	1282	try expect(vec[47] == false);
	1283	try expect(vec[48] == false);
	1284	try expect(vec[49] == true);
	1285	try expect(vec[50] == false);
	1286	try expect(vec[51] == false);
	1287	try expect(vec[52] == true);
	1288	try expect(vec[53] == false);
	1289	try expect(vec[54] == false);
	1290	try expect(vec[55] == false);
	1291	try expect(vec[56] == false);
	1292	try expect(vec[57] == false);
	1293	try expect(vec[58] == true);
	1294	try expect(vec[59] == true);
	1295	try expect(vec[60] == true);
	1296	try expect(vec[61] == false);
	1297	try expect(vec[62] == true);
	1298	try expect(vec[63] == true);
	1299	try expect(vec[64] == false);
	1300	try expect(vec[65] == false);
	1301	try expect(vec[66] == false);
	1302	try expect(vec[67] == false);
	1303	try expect(vec[68] == false);
	1304	try expect(vec[69] == false);
	1305	try expect(vec[70] == false);
	1306	try expect(vec[71] == false);
	1307	try expect(vec[72] == true);
	1308	try expect(vec[73] == true);
	1309	try expect(vec[74] == true);
	1310	try expect(vec[75] == true);
	1311	try expect(vec[76] == true);
	1312	try expect(vec[77] == false);
	1313	try expect(vec[78] == false);
	1314	try expect(vec[79] == false);
	1315	try expect(vec[80] == false);
	1316	try expect(vec[81] == false);
	1317	try expect(vec[82] == false);
	1318	try expect(vec[83] == true);
	1319	try expect(vec[84] == false);
	1320	try expect(vec[85] == true);
	1321	try expect(vec[86] == false);
	1322	try expect(vec[87] == true);
	1323	try expect(vec[88] == false);
	1324	try expect(vec[89] == true);
	1325	try expect(vec[90] == false);
	1326	try expect(vec[91] == true);
	1327	try expect(vec[92] == true);
	1328	try expect(vec[93] == true);
	1329	try expect(vec[94] == true);
	1330	try expect(vec[95] == false);
	1331	try expect(vec[96] == false);
	1332	try expect(vec[97] == true);
	1333	try expect(vec[98] == false);
	1334	try expect(vec[99] == false);
	1335	try expect(vec[100] == true);
	1336	try expect(vec[101] == true);
	1337	try expect(vec[102] == true);
	1338	try expect(vec[103] == true);
	1339	try expect(vec[104] == false);
	1340	try expect(vec[105] == true);
	1341	try expect(vec[106] == true);
	1342	try expect(vec[107] == true);
	1343	try expect(vec[108] == false);
	1344	try expect(vec[109] == false);
	1345	try expect(vec[110] == true);
	1346	try expect(vec[111] == false);
	1347	try expect(vec[112] == false);
	1348	try expect(vec[113] == true);
	1349	try expect(vec[114] == true);
	1350	try expect(vec[115] == false);
	1351	try expect(vec[116] == true);
	1352	try expect(vec[117] == false);
	1353	try expect(vec[118] == true);
	1354	try expect(vec[119] == true);
	1355	try expect(vec[120] == true);
	1356	try expect(vec[121] == true);
	1357	try expect(vec[122] == true);
	1358	try expect(vec[123] == false);
	1359	try expect(vec[124] == false);
	1360	try expect(vec[125] == true);
	1361	try expect(vec[126] == false);
	1362	try expect(vec[127] == true);
	1363	c_vector_128_bool(.{
	1364	false,
	1365	false,
	1366	false,
	1367	false,
	1368	false,
	1369	true,
	1370	true,
	1371	false,
	1372	true,
	1373	true,
	1374	false,
	1375	true,
	1376	true,
	1377	false,
	1378	true,
	1379	true,
	1380	true,
	1381	false,
	1382	false,
	1383	false,
	1384	false,
	1385	true,
	1386	true,
	1387	false,
	1388	false,
	1389	false,
	1390	true,
	1391	true,
	1392	false,
	1393	true,
	1394	false,
	1395	false,
	1396	true,
	1397	false,
	1398	false,
	1399	true,
	1400	true,
	1401	true,
	1402	true,
	1403	true,
	1404	false,
	1405	true,
	1406	true,
	1407	true,
	1408	false,
	1409	false,
	1410	false,
	1411	false,
	1412	true,
	1413	true,
	1414	false,
	1415	true,
	1416	true,
	1417	true,
	1418	true,
	1419	true,
	1420	false,
	1421	true,
	1422	true,
	1423	false,
	1424	true,
	1425	false,
	1426	false,
	1427	true,
	1428	true,
	1429	false,
	1430	true,
	1431	true,
	1432	false,
	1433	true,
	1434	false,
	1435	false,
	1436	true,
	1437	true,
	1438	false,
	1439	true,
	1440	true,
	1441	true,
	1442	false,
	1443	true,
	1444	false,
	1445	false,
	1446	false,
	1447	false,
	1448	true,
	1449	false,
	1450	false,
	1451	false,
	1452	true,
	1453	true,
	1454	false,
	1455	false,
	1456	true,
	1457	true,
	1458	true,
	1459	true,
	1460	false,
	1461	false,
	1462	false,
	1463	false,
	1464	false,
	1465	true,
	1466	false,
	1467	false,
	1468	false,
	1469	false,
	1470	true,
	1471	true,
	1472	true,
	1473	true,
	1474	true,
	1475	false,
	1476	false,
	1477	true,
	1478	false,
	1479	true,
	1480	false,
	1481	false,
	1482	true,
	1483	false,
	1484	true,
	1485	false,
	1486	true,
	1487	true,
	1488	true,
	1489	true,
	1490	true,
	1491	true,
	1492	});
	1493	c_test_vector_128_bool();
	1494	}
	1495
	1496	comptime {
	1497	skip: {
	1498	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
	1499	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip;
4898	1500
4899		export fn zig_ret_vector_256_bool() Vector256Bool {
	1501	_ = struct {
	1502	export fn zig_ret_vector_256_bool() @Vector(256, bool) {
4900	1503	return .{
4901	1504	true,
4902	1505	true,
...	...	@@ -5156,8 +1759,800 @@ comptime {
5156	1759	true,
5157	1760	};
5158	1761	}
	1762	export fn zig_vector_256_bool(vec: @Vector(256, bool)) void {
	1763	expect(vec[0] == false) catch @panic("test failure");
	1764	expect(vec[1] == false) catch @panic("test failure");
	1765	expect(vec[2] == false) catch @panic("test failure");
	1766	expect(vec[3] == false) catch @panic("test failure");
	1767	expect(vec[4] == true) catch @panic("test failure");
	1768	expect(vec[5] == true) catch @panic("test failure");
	1769	expect(vec[6] == false) catch @panic("test failure");
	1770	expect(vec[7] == false) catch @panic("test failure");
	1771	expect(vec[8] == false) catch @panic("test failure");
	1772	expect(vec[9] == true) catch @panic("test failure");
	1773	expect(vec[10] == true) catch @panic("test failure");
	1774	expect(vec[11] == false) catch @panic("test failure");
	1775	expect(vec[12] == true) catch @panic("test failure");
	1776	expect(vec[13] == false) catch @panic("test failure");
	1777	expect(vec[14] == false) catch @panic("test failure");
	1778	expect(vec[15] == false) catch @panic("test failure");
	1779	expect(vec[16] == false) catch @panic("test failure");
	1780	expect(vec[17] == true) catch @panic("test failure");
	1781	expect(vec[18] == true) catch @panic("test failure");
	1782	expect(vec[19] == true) catch @panic("test failure");
	1783	expect(vec[20] == false) catch @panic("test failure");
	1784	expect(vec[21] == true) catch @panic("test failure");
	1785	expect(vec[22] == true) catch @panic("test failure");
	1786	expect(vec[23] == false) catch @panic("test failure");
	1787	expect(vec[24] == true) catch @panic("test failure");
	1788	expect(vec[25] == false) catch @panic("test failure");
	1789	expect(vec[26] == false) catch @panic("test failure");
	1790	expect(vec[27] == true) catch @panic("test failure");
	1791	expect(vec[28] == true) catch @panic("test failure");
	1792	expect(vec[29] == true) catch @panic("test failure");
	1793	expect(vec[30] == false) catch @panic("test failure");
	1794	expect(vec[31] == true) catch @panic("test failure");
	1795	expect(vec[32] == false) catch @panic("test failure");
	1796	expect(vec[33] == true) catch @panic("test failure");
	1797	expect(vec[34] == false) catch @panic("test failure");
	1798	expect(vec[35] == false) catch @panic("test failure");
	1799	expect(vec[36] == false) catch @panic("test failure");
	1800	expect(vec[37] == true) catch @panic("test failure");
	1801	expect(vec[38] == false) catch @panic("test failure");
	1802	expect(vec[39] == false) catch @panic("test failure");
	1803	expect(vec[40] == true) catch @panic("test failure");
	1804	expect(vec[41] == true) catch @panic("test failure");
	1805	expect(vec[42] == false) catch @panic("test failure");
	1806	expect(vec[43] == true) catch @panic("test failure");
	1807	expect(vec[44] == true) catch @panic("test failure");
	1808	expect(vec[45] == false) catch @panic("test failure");
	1809	expect(vec[46] == true) catch @panic("test failure");
	1810	expect(vec[47] == false) catch @panic("test failure");
	1811	expect(vec[48] == true) catch @panic("test failure");
	1812	expect(vec[49] == false) catch @panic("test failure");
	1813	expect(vec[50] == true) catch @panic("test failure");
	1814	expect(vec[51] == false) catch @panic("test failure");
	1815	expect(vec[52] == true) catch @panic("test failure");
	1816	expect(vec[53] == true) catch @panic("test failure");
	1817	expect(vec[54] == true) catch @panic("test failure");
	1818	expect(vec[55] == false) catch @panic("test failure");
	1819	expect(vec[56] == false) catch @panic("test failure");
	1820	expect(vec[57] == true) catch @panic("test failure");
	1821	expect(vec[58] == true) catch @panic("test failure");
	1822	expect(vec[59] == false) catch @panic("test failure");
	1823	expect(vec[60] == false) catch @panic("test failure");
	1824	expect(vec[61] == true) catch @panic("test failure");
	1825	expect(vec[62] == true) catch @panic("test failure");
	1826	expect(vec[63] == false) catch @panic("test failure");
	1827	expect(vec[64] == false) catch @panic("test failure");
	1828	expect(vec[65] == false) catch @panic("test failure");
	1829	expect(vec[66] == true) catch @panic("test failure");
	1830	expect(vec[67] == true) catch @panic("test failure");
	1831	expect(vec[68] == false) catch @panic("test failure");
	1832	expect(vec[69] == true) catch @panic("test failure");
	1833	expect(vec[70] == false) catch @panic("test failure");
	1834	expect(vec[71] == true) catch @panic("test failure");
	1835	expect(vec[72] == false) catch @panic("test failure");
	1836	expect(vec[73] == true) catch @panic("test failure");
	1837	expect(vec[74] == false) catch @panic("test failure");
	1838	expect(vec[75] == false) catch @panic("test failure");
	1839	expect(vec[76] == true) catch @panic("test failure");
	1840	expect(vec[77] == false) catch @panic("test failure");
	1841	expect(vec[78] == false) catch @panic("test failure");
	1842	expect(vec[79] == false) catch @panic("test failure");
	1843	expect(vec[80] == false) catch @panic("test failure");
	1844	expect(vec[81] == false) catch @panic("test failure");
	1845	expect(vec[82] == true) catch @panic("test failure");
	1846	expect(vec[83] == false) catch @panic("test failure");
	1847	expect(vec[84] == false) catch @panic("test failure");
	1848	expect(vec[85] == false) catch @panic("test failure");
	1849	expect(vec[86] == true) catch @panic("test failure");
	1850	expect(vec[87] == true) catch @panic("test failure");
	1851	expect(vec[88] == true) catch @panic("test failure");
	1852	expect(vec[89] == false) catch @panic("test failure");
	1853	expect(vec[90] == true) catch @panic("test failure");
	1854	expect(vec[91] == false) catch @panic("test failure");
	1855	expect(vec[92] == true) catch @panic("test failure");
	1856	expect(vec[93] == false) catch @panic("test failure");
	1857	expect(vec[94] == true) catch @panic("test failure");
	1858	expect(vec[95] == true) catch @panic("test failure");
	1859	expect(vec[96] == true) catch @panic("test failure");
	1860	expect(vec[97] == true) catch @panic("test failure");
	1861	expect(vec[98] == false) catch @panic("test failure");
	1862	expect(vec[99] == true) catch @panic("test failure");
	1863	expect(vec[100] == false) catch @panic("test failure");
	1864	expect(vec[101] == true) catch @panic("test failure");
	1865	expect(vec[102] == true) catch @panic("test failure");
	1866	expect(vec[103] == false) catch @panic("test failure");
	1867	expect(vec[104] == false) catch @panic("test failure");
	1868	expect(vec[105] == true) catch @panic("test failure");
	1869	expect(vec[106] == false) catch @panic("test failure");
	1870	expect(vec[107] == true) catch @panic("test failure");
	1871	expect(vec[108] == false) catch @panic("test failure");
	1872	expect(vec[109] == false) catch @panic("test failure");
	1873	expect(vec[110] == false) catch @panic("test failure");
	1874	expect(vec[111] == false) catch @panic("test failure");
	1875	expect(vec[112] == false) catch @panic("test failure");
	1876	expect(vec[113] == false) catch @panic("test failure");
	1877	expect(vec[114] == false) catch @panic("test failure");
	1878	expect(vec[115] == false) catch @panic("test failure");
	1879	expect(vec[116] == false) catch @panic("test failure");
	1880	expect(vec[117] == false) catch @panic("test failure");
	1881	expect(vec[118] == false) catch @panic("test failure");
	1882	expect(vec[119] == false) catch @panic("test failure");
	1883	expect(vec[120] == false) catch @panic("test failure");
	1884	expect(vec[121] == false) catch @panic("test failure");
	1885	expect(vec[122] == true) catch @panic("test failure");
	1886	expect(vec[123] == true) catch @panic("test failure");
	1887	expect(vec[124] == false) catch @panic("test failure");
	1888	expect(vec[125] == false) catch @panic("test failure");
	1889	expect(vec[126] == false) catch @panic("test failure");
	1890	expect(vec[127] == true) catch @panic("test failure");
	1891	expect(vec[128] == true) catch @panic("test failure");
	1892	expect(vec[129] == true) catch @panic("test failure");
	1893	expect(vec[130] == true) catch @panic("test failure");
	1894	expect(vec[131] == false) catch @panic("test failure");
	1895	expect(vec[132] == false) catch @panic("test failure");
	1896	expect(vec[133] == false) catch @panic("test failure");
	1897	expect(vec[134] == true) catch @panic("test failure");
	1898	expect(vec[135] == true) catch @panic("test failure");
	1899	expect(vec[136] == false) catch @panic("test failure");
	1900	expect(vec[137] == false) catch @panic("test failure");
	1901	expect(vec[138] == true) catch @panic("test failure");
	1902	expect(vec[139] == true) catch @panic("test failure");
	1903	expect(vec[140] == true) catch @panic("test failure");
	1904	expect(vec[141] == true) catch @panic("test failure");
	1905	expect(vec[142] == true) catch @panic("test failure");
	1906	expect(vec[143] == false) catch @panic("test failure");
	1907	expect(vec[144] == true) catch @panic("test failure");
	1908	expect(vec[145] == true) catch @panic("test failure");
	1909	expect(vec[146] == true) catch @panic("test failure");
	1910	expect(vec[147] == false) catch @panic("test failure");
	1911	expect(vec[148] == false) catch @panic("test failure");
	1912	expect(vec[149] == false) catch @panic("test failure");
	1913	expect(vec[150] == false) catch @panic("test failure");
	1914	expect(vec[151] == false) catch @panic("test failure");
	1915	expect(vec[152] == false) catch @panic("test failure");
	1916	expect(vec[153] == false) catch @panic("test failure");
	1917	expect(vec[154] == true) catch @panic("test failure");
	1918	expect(vec[155] == false) catch @panic("test failure");
	1919	expect(vec[156] == false) catch @panic("test failure");
	1920	expect(vec[157] == false) catch @panic("test failure");
	1921	expect(vec[158] == true) catch @panic("test failure");
	1922	expect(vec[159] == true) catch @panic("test failure");
	1923	expect(vec[160] == false) catch @panic("test failure");
	1924	expect(vec[161] == true) catch @panic("test failure");
	1925	expect(vec[162] == false) catch @panic("test failure");
	1926	expect(vec[163] == false) catch @panic("test failure");
	1927	expect(vec[164] == false) catch @panic("test failure");
	1928	expect(vec[165] == true) catch @panic("test failure");
	1929	expect(vec[166] == false) catch @panic("test failure");
	1930	expect(vec[167] == true) catch @panic("test failure");
	1931	expect(vec[168] == false) catch @panic("test failure");
	1932	expect(vec[169] == false) catch @panic("test failure");
	1933	expect(vec[170] == false) catch @panic("test failure");
	1934	expect(vec[171] == false) catch @panic("test failure");
	1935	expect(vec[172] == true) catch @panic("test failure");
	1936	expect(vec[173] == true) catch @panic("test failure");
	1937	expect(vec[174] == true) catch @panic("test failure");
	1938	expect(vec[175] == true) catch @panic("test failure");
	1939	expect(vec[176] == true) catch @panic("test failure");
	1940	expect(vec[177] == true) catch @panic("test failure");
	1941	expect(vec[178] == false) catch @panic("test failure");
	1942	expect(vec[179] == true) catch @panic("test failure");
	1943	expect(vec[180] == true) catch @panic("test failure");
	1944	expect(vec[181] == false) catch @panic("test failure");
	1945	expect(vec[182] == true) catch @panic("test failure");
	1946	expect(vec[183] == false) catch @panic("test failure");
	1947	expect(vec[184] == true) catch @panic("test failure");
	1948	expect(vec[185] == false) catch @panic("test failure");
	1949	expect(vec[186] == true) catch @panic("test failure");
	1950	expect(vec[187] == false) catch @panic("test failure");
	1951	expect(vec[188] == true) catch @panic("test failure");
	1952	expect(vec[189] == false) catch @panic("test failure");
	1953	expect(vec[190] == false) catch @panic("test failure");
	1954	expect(vec[191] == false) catch @panic("test failure");
	1955	expect(vec[192] == false) catch @panic("test failure");
	1956	expect(vec[193] == true) catch @panic("test failure");
	1957	expect(vec[194] == true) catch @panic("test failure");
	1958	expect(vec[195] == true) catch @panic("test failure");
	1959	expect(vec[196] == false) catch @panic("test failure");
	1960	expect(vec[197] == false) catch @panic("test failure");
	1961	expect(vec[198] == true) catch @panic("test failure");
	1962	expect(vec[199] == false) catch @panic("test failure");
	1963	expect(vec[200] == false) catch @panic("test failure");
	1964	expect(vec[201] == true) catch @panic("test failure");
	1965	expect(vec[202] == true) catch @panic("test failure");
	1966	expect(vec[203] == false) catch @panic("test failure");
	1967	expect(vec[204] == true) catch @panic("test failure");
	1968	expect(vec[205] == false) catch @panic("test failure");
	1969	expect(vec[206] == true) catch @panic("test failure");
	1970	expect(vec[207] == false) catch @panic("test failure");
	1971	expect(vec[208] == false) catch @panic("test failure");
	1972	expect(vec[209] == false) catch @panic("test failure");
	1973	expect(vec[210] == true) catch @panic("test failure");
	1974	expect(vec[211] == true) catch @panic("test failure");
	1975	expect(vec[212] == false) catch @panic("test failure");
	1976	expect(vec[213] == false) catch @panic("test failure");
	1977	expect(vec[214] == false) catch @panic("test failure");
	1978	expect(vec[215] == true) catch @panic("test failure");
	1979	expect(vec[216] == false) catch @panic("test failure");
	1980	expect(vec[217] == true) catch @panic("test failure");
	1981	expect(vec[218] == true) catch @panic("test failure");
	1982	expect(vec[219] == true) catch @panic("test failure");
	1983	expect(vec[220] == false) catch @panic("test failure");
	1984	expect(vec[221] == true) catch @panic("test failure");
	1985	expect(vec[222] == false) catch @panic("test failure");
	1986	expect(vec[223] == true) catch @panic("test failure");
	1987	expect(vec[224] == false) catch @panic("test failure");
	1988	expect(vec[225] == false) catch @panic("test failure");
	1989	expect(vec[226] == false) catch @panic("test failure");
	1990	expect(vec[227] == true) catch @panic("test failure");
	1991	expect(vec[228] == true) catch @panic("test failure");
	1992	expect(vec[229] == false) catch @panic("test failure");
	1993	expect(vec[230] == false) catch @panic("test failure");
	1994	expect(vec[231] == false) catch @panic("test failure");
	1995	expect(vec[232] == false) catch @panic("test failure");
	1996	expect(vec[233] == false) catch @panic("test failure");
	1997	expect(vec[234] == true) catch @panic("test failure");
	1998	expect(vec[235] == false) catch @panic("test failure");
	1999	expect(vec[236] == false) catch @panic("test failure");
	2000	expect(vec[237] == false) catch @panic("test failure");
	2001	expect(vec[238] == true) catch @panic("test failure");
	2002	expect(vec[239] == false) catch @panic("test failure");
	2003	expect(vec[240] == true) catch @panic("test failure");
	2004	expect(vec[241] == true) catch @panic("test failure");
	2005	expect(vec[242] == true) catch @panic("test failure");
	2006	expect(vec[243] == false) catch @panic("test failure");
	2007	expect(vec[244] == false) catch @panic("test failure");
	2008	expect(vec[245] == true) catch @panic("test failure");
	2009	expect(vec[246] == false) catch @panic("test failure");
	2010	expect(vec[247] == false) catch @panic("test failure");
	2011	expect(vec[248] == false) catch @panic("test failure");
	2012	expect(vec[249] == true) catch @panic("test failure");
	2013	expect(vec[250] == false) catch @panic("test failure");
	2014	expect(vec[251] == false) catch @panic("test failure");
	2015	expect(vec[252] == true) catch @panic("test failure");
	2016	expect(vec[253] == true) catch @panic("test failure");
	2017	expect(vec[254] == true) catch @panic("test failure");
	2018	expect(vec[255] == true) catch @panic("test failure");
	2019	}
	2020	};
	2021	}
	2022	}
	2023
	2024	extern fn c_ret_vector_256_bool() @Vector(256, bool);
	2025	extern fn c_vector_256_bool(@Vector(256, bool)) void;
	2026	extern fn c_test_vector_256_bool() void;
	2027
	2028	test "@Vector(256, bool)" {
	2029	if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest;
	2030
	2031	const vec = c_ret_vector_256_bool();
	2032	try expect(vec[0] == true);
	2033	try expect(vec[1] == false);
	2034	try expect(vec[2] == true);
	2035	try expect(vec[3] == true);
	2036	try expect(vec[4] == false);
	2037	try expect(vec[5] == false);
	2038	try expect(vec[6] == false);
	2039	try expect(vec[7] == false);
	2040	try expect(vec[8] == false);
	2041	try expect(vec[9] == true);
	2042	try expect(vec[10] == false);
	2043	try expect(vec[11] == true);
	2044	try expect(vec[12] == false);
	2045	try expect(vec[13] == true);
	2046	try expect(vec[14] == false);
	2047	try expect(vec[15] == false);
	2048	try expect(vec[16] == true);
	2049	try expect(vec[17] == true);
	2050	try expect(vec[18] == true);
	2051	try expect(vec[19] == false);
	2052	try expect(vec[20] == false);
	2053	try expect(vec[21] == false);
	2054	try expect(vec[22] == true);
	2055	try expect(vec[23] == false);
	2056	try expect(vec[24] == true);
	2057	try expect(vec[25] == false);
	2058	try expect(vec[26] == false);
	2059	try expect(vec[27] == true);
	2060	try expect(vec[28] == true);
	2061	try expect(vec[29] == true);
	2062	try expect(vec[30] == false);
	2063	try expect(vec[31] == false);
	2064	try expect(vec[32] == true);
	2065	try expect(vec[33] == true);
	2066	try expect(vec[34] == true);
	2067	try expect(vec[35] == false);
	2068	try expect(vec[36] == true);
	2069	try expect(vec[37] == true);
	2070	try expect(vec[38] == true);
	2071	try expect(vec[39] == false);
	2072	try expect(vec[40] == true);
	2073	try expect(vec[41] == false);
	2074	try expect(vec[42] == true);
	2075	try expect(vec[43] == true);
	2076	try expect(vec[44] == false);
	2077	try expect(vec[45] == true);
	2078	try expect(vec[46] == false);
	2079	try expect(vec[47] == true);
	2080	try expect(vec[48] == true);
	2081	try expect(vec[49] == false);
	2082	try expect(vec[50] == false);
	2083	try expect(vec[51] == true);
	2084	try expect(vec[52] == true);
	2085	try expect(vec[53] == false);
	2086	try expect(vec[54] == false);
	2087	try expect(vec[55] == true);
	2088	try expect(vec[56] == false);
	2089	try expect(vec[57] == true);
	2090	try expect(vec[58] == true);
	2091	try expect(vec[59] == true);
	2092	try expect(vec[60] == false);
	2093	try expect(vec[61] == true);
	2094	try expect(vec[62] == true);
	2095	try expect(vec[63] == false);
	2096	try expect(vec[64] == true);
	2097	try expect(vec[65] == true);
	2098	try expect(vec[66] == false);
	2099	try expect(vec[67] == true);
	2100	try expect(vec[68] == false);
	2101	try expect(vec[69] == true);
	2102	try expect(vec[70] == true);
	2103	try expect(vec[71] == true);
	2104	try expect(vec[72] == false);
	2105	try expect(vec[73] == true);
	2106	try expect(vec[74] == true);
	2107	try expect(vec[75] == false);
	2108	try expect(vec[76] == true);
	2109	try expect(vec[77] == true);
	2110	try expect(vec[78] == true);
	2111	try expect(vec[79] == true);
	2112	try expect(vec[80] == false);
	2113	try expect(vec[81] == true);
	2114	try expect(vec[82] == false);
	2115	try expect(vec[83] == true);
	2116	try expect(vec[84] == true);
	2117	try expect(vec[85] == true);
	2118	try expect(vec[86] == false);
	2119	try expect(vec[87] == true);
	2120	try expect(vec[88] == false);
	2121	try expect(vec[89] == true);
	2122	try expect(vec[90] == false);
	2123	try expect(vec[91] == false);
	2124	try expect(vec[92] == true);
	2125	try expect(vec[93] == false);
	2126	try expect(vec[94] == false);
	2127	try expect(vec[95] == false);
	2128	try expect(vec[96] == true);
	2129	try expect(vec[97] == true);
	2130	try expect(vec[98] == false);
	2131	try expect(vec[99] == false);
	2132	try expect(vec[100] == false);
	2133	try expect(vec[101] == true);
	2134	try expect(vec[102] == true);
	2135	try expect(vec[103] == true);
	2136	try expect(vec[104] == false);
	2137	try expect(vec[105] == false);
	2138	try expect(vec[106] == false);
	2139	try expect(vec[107] == true);
	2140	try expect(vec[108] == false);
	2141	try expect(vec[109] == true);
	2142	try expect(vec[110] == true);
	2143	try expect(vec[111] == true);
	2144	try expect(vec[112] == true);
	2145	try expect(vec[113] == true);
	2146	try expect(vec[114] == true);
	2147	try expect(vec[115] == true);
	2148	try expect(vec[116] == true);
	2149	try expect(vec[117] == false);
	2150	try expect(vec[118] == true);
	2151	try expect(vec[119] == false);
	2152	try expect(vec[120] == true);
	2153	try expect(vec[121] == false);
	2154	try expect(vec[122] == false);
	2155	try expect(vec[123] == true);
	2156	try expect(vec[124] == true);
	2157	try expect(vec[125] == false);
	2158	try expect(vec[126] == true);
	2159	try expect(vec[127] == false);
	2160	try expect(vec[128] == false);
	2161	try expect(vec[129] == false);
	2162	try expect(vec[130] == false);
	2163	try expect(vec[131] == true);
	2164	try expect(vec[132] == false);
	2165	try expect(vec[133] == false);
	2166	try expect(vec[134] == true);
	2167	try expect(vec[135] == false);
	2168	try expect(vec[136] == false);
	2169	try expect(vec[137] == false);
	2170	try expect(vec[138] == false);
	2171	try expect(vec[139] == false);
	2172	try expect(vec[140] == false);
	2173	try expect(vec[141] == true);
	2174	try expect(vec[142] == false);
	2175	try expect(vec[143] == true);
	2176	try expect(vec[144] == false);
	2177	try expect(vec[145] == true);
	2178	try expect(vec[146] == true);
	2179	try expect(vec[147] == true);
	2180	try expect(vec[148] == false);
	2181	try expect(vec[149] == true);
	2182	try expect(vec[150] == true);
	2183	try expect(vec[151] == false);
	2184	try expect(vec[152] == true);
	2185	try expect(vec[153] == true);
	2186	try expect(vec[154] == false);
	2187	try expect(vec[155] == true);
	2188	try expect(vec[156] == true);
	2189	try expect(vec[157] == true);
	2190	try expect(vec[158] == true);
	2191	try expect(vec[159] == true);
	2192	try expect(vec[160] == true);
	2193	try expect(vec[161] == true);
	2194	try expect(vec[162] == false);
	2195	try expect(vec[163] == false);
	2196	try expect(vec[164] == false);
	2197	try expect(vec[165] == true);
	2198	try expect(vec[166] == false);
	2199	try expect(vec[167] == false);
	2200	try expect(vec[168] == true);
	2201	try expect(vec[169] == false);
	2202	try expect(vec[170] == true);
	2203	try expect(vec[171] == true);
	2204	try expect(vec[172] == true);
	2205	try expect(vec[173] == false);
	2206	try expect(vec[174] == false);
	2207	try expect(vec[175] == true);
	2208	try expect(vec[176] == true);
	2209	try expect(vec[177] == true);
	2210	try expect(vec[178] == true);
	2211	try expect(vec[179] == false);
	2212	try expect(vec[180] == true);
	2213	try expect(vec[181] == true);
	2214	try expect(vec[182] == false);
	2215	try expect(vec[183] == true);
	2216	try expect(vec[184] == false);
	2217	try expect(vec[185] == false);
	2218	try expect(vec[186] == false);
	2219	try expect(vec[187] == true);
	2220	try expect(vec[188] == true);
	2221	try expect(vec[189] == true);
	2222	try expect(vec[190] == true);
	2223	try expect(vec[191] == true);
	2224	try expect(vec[192] == true);
	2225	try expect(vec[193] == true);
	2226	try expect(vec[194] == true);
	2227	try expect(vec[195] == false);
	2228	try expect(vec[196] == false);
	2229	try expect(vec[197] == true);
	2230	try expect(vec[198] == false);
	2231	try expect(vec[199] == false);
	2232	try expect(vec[200] == false);
	2233	try expect(vec[201] == true);
	2234	try expect(vec[202] == true);
	2235	try expect(vec[203] == true);
	2236	try expect(vec[204] == true);
	2237	try expect(vec[205] == true);
	2238	try expect(vec[206] == true);
	2239	try expect(vec[207] == false);
	2240	try expect(vec[208] == false);
	2241	try expect(vec[209] == false);
	2242	try expect(vec[210] == true);
	2243	try expect(vec[211] == true);
	2244	try expect(vec[212] == true);
	2245	try expect(vec[213] == false);
	2246	try expect(vec[214] == true);
	2247	try expect(vec[215] == false);
	2248	try expect(vec[216] == true);
	2249	try expect(vec[217] == false);
	2250	try expect(vec[218] == true);
	2251	try expect(vec[219] == false);
	2252	try expect(vec[220] == true);
	2253	try expect(vec[221] == true);
	2254	try expect(vec[222] == true);
	2255	try expect(vec[223] == false);
	2256	try expect(vec[224] == true);
	2257	try expect(vec[225] == false);
	2258	try expect(vec[226] == true);
	2259	try expect(vec[227] == false);
	2260	try expect(vec[228] == true);
	2261	try expect(vec[229] == false);
	2262	try expect(vec[230] == true);
	2263	try expect(vec[231] == false);
	2264	try expect(vec[232] == false);
	2265	try expect(vec[233] == true);
	2266	try expect(vec[234] == false);
	2267	try expect(vec[235] == true);
	2268	try expect(vec[236] == true);
	2269	try expect(vec[237] == false);
	2270	try expect(vec[238] == false);
	2271	try expect(vec[239] == true);
	2272	try expect(vec[240] == false);
	2273	try expect(vec[241] == false);
	2274	try expect(vec[242] == false);
	2275	try expect(vec[243] == true);
	2276	try expect(vec[244] == true);
	2277	try expect(vec[245] == false);
	2278	try expect(vec[246] == false);
	2279	try expect(vec[247] == false);
	2280	try expect(vec[248] == false);
	2281	try expect(vec[249] == false);
	2282	try expect(vec[250] == true);
	2283	try expect(vec[251] == false);
	2284	try expect(vec[252] == true);
	2285	try expect(vec[253] == false);
	2286	try expect(vec[254] == false);
	2287	try expect(vec[255] == false);
	2288	if (!builtin.target.cpu.arch.isWasm()) c_vector_256_bool(.{
	2289	false,
	2290	true,
	2291	true,
	2292	false,
	2293	false,
	2294	true,
	2295	true,
	2296	true,
	2297	false,
	2298	true,
	2299	true,
	2300	true,
	2301	false,
	2302	true,
	2303	false,
	2304	true,
	2305	false,
	2306	false,
	2307	true,
	2308	true,
	2309	false,
	2310	true,
	2311	false,
	2312	false,
	2313	false,
	2314	true,
	2315	true,
	2316	false,
	2317	false,
	2318	true,
	2319	true,
	2320	false,
	2321	true,
	2322	false,
	2323	false,
	2324	true,
	2325	false,
	2326	true,
	2327	false,
	2328	true,
	2329	true,
	2330	true,
	2331	true,
	2332	false,
	2333	false,
	2334	true,
	2335	false,
	2336	false,
	2337	false,
	2338	false,
	2339	false,
	2340	false,
	2341	true,
	2342	true,
	2343	true,
	2344	true,
	2345	true,
	2346	true,
	2347	false,
	2348	true,
	2349	true,
	2350	false,
	2351	false,
	2352	true,
	2353	false,
	2354	false,
	2355	false,
	2356	false,
	2357	false,
	2358	false,
	2359	true,
	2360	true,
	2361	true,
	2362	false,
	2363	false,
	2364	false,
	2365	true,
	2366	false,
	2367	true,
	2368	true,
	2369	false,
	2370	false,
	2371	true,
	2372	true,
	2373	false,
	2374	true,
	2375	true,
	2376	true,
	2377	true,
	2378	true,
	2379	true,
	2380	true,
	2381	false,
	2382	true,
	2383	true,
	2384	false,
	2385	false,
	2386	true,
	2387	true,
	2388	false,
	2389	true,
	2390	false,
	2391	false,
	2392	true,
	2393	false,
	2394	true,
	2395	true,
	2396	true,
	2397	true,
	2398	true,
	2399	false,
	2400	false,
	2401	false,
	2402	false,
	2403	true,
	2404	true,
	2405	false,
	2406	true,
	2407	false,
	2408	false,
	2409	true,
	2410	false,
	2411	false,
	2412	true,
	2413	false,
	2414	true,
	2415	true,
	2416	true,
	2417	true,
	2418	false,
	2419	true,
	2420	true,
	2421	false,
	2422	false,
	2423	true,
	2424	false,
	2425	false,
	2426	true,
	2427	false,
	2428	true,
	2429	false,
	2430	true,
	2431	true,
	2432	true,
	2433	true,
	2434	false,
	2435	true,
	2436	false,
	2437	false,
	2438	false,
	2439	true,
	2440	true,
	2441	true,
	2442	true,
	2443	true,
	2444	false,
	2445	true,
	2446	false,
	2447	false,
	2448	false,
	2449	true,
	2450	true,
	2451	false,
	2452	true,
	2453	true,
	2454	false,
	2455	false,
	2456	false,
	2457	false,
	2458	true,
	2459	false,
	2460	true,
	2461	false,
	2462	false,
	2463	false,
	2464	false,
	2465	true,
	2466	true,
	2467	true,
	2468	false,
	2469	true,
	2470	false,
	2471	true,
	2472	true,
	2473	false,
	2474	false,
	2475	true,
	2476	false,
	2477	false,
	2478	false,
	2479	false,
	2480	true,
	2481	true,
	2482	true,
	2483	true,
	2484	true,
	2485	true,
	2486	true,
	2487	false,
	2488	true,
	2489	false,
	2490	false,
	2491	true,
	2492	false,
	2493	true,
	2494	true,
	2495	true,
	2496	false,
	2497	false,
	2498	true,
	2499	true,
	2500	true,
	2501	false,
	2502	true,
	2503	true,
	2504	true,
	2505	true,
	2506	true,
	2507	false,
	2508	false,
	2509	false,
	2510	false,
	2511	false,
	2512	true,
	2513	true,
	2514	false,
	2515	true,
	2516	false,
	2517	false,
	2518	true,
	2519	false,
	2520	true,
	2521	false,
	2522	false,
	2523	false,
	2524	true,
	2525	false,
	2526	false,
	2527	false,
	2528	true,
	2529	true,
	2530	true,
	2531	true,
	2532	true,
	2533	true,
	2534	false,
	2535	false,
	2536	true,
	2537	false,
	2538	true,
	2539	true,
	2540	false,
	2541	true,
	2542	true,
	2543	true,
	2544	false,
	2545	});
	2546	c_test_vector_512_bool();
	2547	}
	2548
	2549	comptime {
	2550	skip: {
	2551	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
	2552	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch.isPowerPC64()) break :skip;
5159	2553
5160		export fn zig_ret_vector_512_bool() Vector512Bool {
	2554	_ = struct {
	2555	export fn zig_ret_vector_512_bool() @Vector(512, bool) {
5161	2556	return .{
5162	2557	true,
5163	2558	true,
...	...	@@ -5673,28 +3068,13612 @@ comptime {
5673	3068	false,
5674	3069	};
5675	3070	}
	3071	export fn zig_vector_512_bool(vec: @Vector(512, bool)) void {
	3072	expect(vec[0] == false) catch @panic("test failure");
	3073	expect(vec[1] == true) catch @panic("test failure");
	3074	expect(vec[2] == true) catch @panic("test failure");
	3075	expect(vec[3] == false) catch @panic("test failure");
	3076	expect(vec[4] == true) catch @panic("test failure");
	3077	expect(vec[5] == false) catch @panic("test failure");
	3078	expect(vec[6] == true) catch @panic("test failure");
	3079	expect(vec[7] == false) catch @panic("test failure");
	3080	expect(vec[8] == false) catch @panic("test failure");
	3081	expect(vec[9] == false) catch @panic("test failure");
	3082	expect(vec[10] == false) catch @panic("test failure");
	3083	expect(vec[11] == false) catch @panic("test failure");
	3084	expect(vec[12] == true) catch @panic("test failure");
	3085	expect(vec[13] == false) catch @panic("test failure");
	3086	expect(vec[14] == true) catch @panic("test failure");
	3087	expect(vec[15] == false) catch @panic("test failure");
	3088	expect(vec[16] == false) catch @panic("test failure");
	3089	expect(vec[17] == false) catch @panic("test failure");
	3090	expect(vec[18] == true) catch @panic("test failure");
	3091	expect(vec[19] == true) catch @panic("test failure");
	3092	expect(vec[20] == true) catch @panic("test failure");
	3093	expect(vec[21] == true) catch @panic("test failure");
	3094	expect(vec[22] == false) catch @panic("test failure");
	3095	expect(vec[23] == false) catch @panic("test failure");
	3096	expect(vec[24] == false) catch @panic("test failure");
	3097	expect(vec[25] == true) catch @panic("test failure");
	3098	expect(vec[26] == true) catch @panic("test failure");
	3099	expect(vec[27] == false) catch @panic("test failure");
	3100	expect(vec[28] == true) catch @panic("test failure");
	3101	expect(vec[29] == true) catch @panic("test failure");
	3102	expect(vec[30] == false) catch @panic("test failure");
	3103	expect(vec[31] == false) catch @panic("test failure");
	3104	expect(vec[32] == true) catch @panic("test failure");
	3105	expect(vec[33] == true) catch @panic("test failure");
	3106	expect(vec[34] == false) catch @panic("test failure");
	3107	expect(vec[35] == false) catch @panic("test failure");
	3108	expect(vec[36] == false) catch @panic("test failure");
	3109	expect(vec[37] == false) catch @panic("test failure");
	3110	expect(vec[38] == false) catch @panic("test failure");
	3111	expect(vec[39] == false) catch @panic("test failure");
	3112	expect(vec[40] == false) catch @panic("test failure");
	3113	expect(vec[41] == true) catch @panic("test failure");
	3114	expect(vec[42] == true) catch @panic("test failure");
	3115	expect(vec[43] == true) catch @panic("test failure");
	3116	expect(vec[44] == false) catch @panic("test failure");
	3117	expect(vec[45] == true) catch @panic("test failure");
	3118	expect(vec[46] == true) catch @panic("test failure");
	3119	expect(vec[47] == true) catch @panic("test failure");
	3120	expect(vec[48] == true) catch @panic("test failure");
	3121	expect(vec[49] == true) catch @panic("test failure");
	3122	expect(vec[50] == false) catch @panic("test failure");
	3123	expect(vec[51] == true) catch @panic("test failure");
	3124	expect(vec[52] == true) catch @panic("test failure");
	3125	expect(vec[53] == true) catch @panic("test failure");
	3126	expect(vec[54] == false) catch @panic("test failure");
	3127	expect(vec[55] == true) catch @panic("test failure");
	3128	expect(vec[56] == false) catch @panic("test failure");
	3129	expect(vec[57] == false) catch @panic("test failure");
	3130	expect(vec[58] == true) catch @panic("test failure");
	3131	expect(vec[59] == false) catch @panic("test failure");
	3132	expect(vec[60] == true) catch @panic("test failure");
	3133	expect(vec[61] == true) catch @panic("test failure");
	3134	expect(vec[62] == false) catch @panic("test failure");
	3135	expect(vec[63] == false) catch @panic("test failure");
	3136	expect(vec[64] == false) catch @panic("test failure");
	3137	expect(vec[65] == true) catch @panic("test failure");
	3138	expect(vec[66] == true) catch @panic("test failure");
	3139	expect(vec[67] == true) catch @panic("test failure");
	3140	expect(vec[68] == true) catch @panic("test failure");
	3141	expect(vec[69] == false) catch @panic("test failure");
	3142	expect(vec[70] == false) catch @panic("test failure");
	3143	expect(vec[71] == true) catch @panic("test failure");
	3144	expect(vec[72] == true) catch @panic("test failure");
	3145	expect(vec[73] == false) catch @panic("test failure");
	3146	expect(vec[74] == true) catch @panic("test failure");
	3147	expect(vec[75] == true) catch @panic("test failure");
	3148	expect(vec[76] == false) catch @panic("test failure");
	3149	expect(vec[77] == false) catch @panic("test failure");
	3150	expect(vec[78] == true) catch @panic("test failure");
	3151	expect(vec[79] == false) catch @panic("test failure");
	3152	expect(vec[80] == false) catch @panic("test failure");
	3153	expect(vec[81] == false) catch @panic("test failure");
	3154	expect(vec[82] == true) catch @panic("test failure");
	3155	expect(vec[83] == true) catch @panic("test failure");
	3156	expect(vec[84] == true) catch @panic("test failure");
	3157	expect(vec[85] == false) catch @panic("test failure");
	3158	expect(vec[86] == false) catch @panic("test failure");
	3159	expect(vec[87] == true) catch @panic("test failure");
	3160	expect(vec[88] == false) catch @panic("test failure");
	3161	expect(vec[89] == true) catch @panic("test failure");
	3162	expect(vec[90] == false) catch @panic("test failure");
	3163	expect(vec[91] == false) catch @panic("test failure");
	3164	expect(vec[92] == true) catch @panic("test failure");
	3165	expect(vec[93] == false) catch @panic("test failure");
	3166	expect(vec[94] == false) catch @panic("test failure");
	3167	expect(vec[95] == true) catch @panic("test failure");
	3168	expect(vec[96] == true) catch @panic("test failure");
	3169	expect(vec[97] == false) catch @panic("test failure");
	3170	expect(vec[98] == false) catch @panic("test failure");
	3171	expect(vec[99] == false) catch @panic("test failure");
	3172	expect(vec[100] == false) catch @panic("test failure");
	3173	expect(vec[101] == true) catch @panic("test failure");
	3174	expect(vec[102] == false) catch @panic("test failure");
	3175	expect(vec[103] == false) catch @panic("test failure");
	3176	expect(vec[104] == false) catch @panic("test failure");
	3177	expect(vec[105] == false) catch @panic("test failure");
	3178	expect(vec[106] == false) catch @panic("test failure");
	3179	expect(vec[107] == false) catch @panic("test failure");
	3180	expect(vec[108] == true) catch @panic("test failure");
	3181	expect(vec[109] == true) catch @panic("test failure");
	3182	expect(vec[110] == true) catch @panic("test failure");
	3183	expect(vec[111] == true) catch @panic("test failure");
	3184	expect(vec[112] == true) catch @panic("test failure");
	3185	expect(vec[113] == false) catch @panic("test failure");
	3186	expect(vec[114] == false) catch @panic("test failure");
	3187	expect(vec[115] == false) catch @panic("test failure");
	3188	expect(vec[116] == false) catch @panic("test failure");
	3189	expect(vec[117] == true) catch @panic("test failure");
	3190	expect(vec[118] == true) catch @panic("test failure");
	3191	expect(vec[119] == false) catch @panic("test failure");
	3192	expect(vec[120] == true) catch @panic("test failure");
	3193	expect(vec[121] == true) catch @panic("test failure");
	3194	expect(vec[122] == false) catch @panic("test failure");
	3195	expect(vec[123] == false) catch @panic("test failure");
	3196	expect(vec[124] == true) catch @panic("test failure");
	3197	expect(vec[125] == false) catch @panic("test failure");
	3198	expect(vec[126] == false) catch @panic("test failure");
	3199	expect(vec[127] == false) catch @panic("test failure");
	3200	expect(vec[128] == false) catch @panic("test failure");
	3201	expect(vec[129] == true) catch @panic("test failure");
	3202	expect(vec[130] == true) catch @panic("test failure");
	3203	expect(vec[131] == true) catch @panic("test failure");
	3204	expect(vec[132] == true) catch @panic("test failure");
	3205	expect(vec[133] == false) catch @panic("test failure");
	3206	expect(vec[134] == false) catch @panic("test failure");
	3207	expect(vec[135] == false) catch @panic("test failure");
	3208	expect(vec[136] == false) catch @panic("test failure");
	3209	expect(vec[137] == true) catch @panic("test failure");
	3210	expect(vec[138] == false) catch @panic("test failure");
	3211	expect(vec[139] == false) catch @panic("test failure");
	3212	expect(vec[140] == false) catch @panic("test failure");
	3213	expect(vec[141] == false) catch @panic("test failure");
	3214	expect(vec[142] == true) catch @panic("test failure");
	3215	expect(vec[143] == true) catch @panic("test failure");
	3216	expect(vec[144] == false) catch @panic("test failure");
	3217	expect(vec[145] == true) catch @panic("test failure");
	3218	expect(vec[146] == false) catch @panic("test failure");
	3219	expect(vec[147] == true) catch @panic("test failure");
	3220	expect(vec[148] == false) catch @panic("test failure");
	3221	expect(vec[149] == false) catch @panic("test failure");
	3222	expect(vec[150] == true) catch @panic("test failure");
	3223	expect(vec[151] == true) catch @panic("test failure");
	3224	expect(vec[152] == false) catch @panic("test failure");
	3225	expect(vec[153] == true) catch @panic("test failure");
	3226	expect(vec[154] == true) catch @panic("test failure");
	3227	expect(vec[155] == false) catch @panic("test failure");
	3228	expect(vec[156] == false) catch @panic("test failure");
	3229	expect(vec[157] == false) catch @panic("test failure");
	3230	expect(vec[158] == true) catch @panic("test failure");
	3231	expect(vec[159] == false) catch @panic("test failure");
	3232	expect(vec[160] == false) catch @panic("test failure");
	3233	expect(vec[161] == false) catch @panic("test failure");
	3234	expect(vec[162] == false) catch @panic("test failure");
	3235	expect(vec[163] == true) catch @panic("test failure");
	3236	expect(vec[164] == true) catch @panic("test failure");
	3237	expect(vec[165] == false) catch @panic("test failure");
	3238	expect(vec[166] == false) catch @panic("test failure");
	3239	expect(vec[167] == true) catch @panic("test failure");
	3240	expect(vec[168] == false) catch @panic("test failure");
	3241	expect(vec[169] == true) catch @panic("test failure");
	3242	expect(vec[170] == true) catch @panic("test failure");
	3243	expect(vec[171] == false) catch @panic("test failure");
	3244	expect(vec[172] == false) catch @panic("test failure");
	3245	expect(vec[173] == false) catch @panic("test failure");
	3246	expect(vec[174] == false) catch @panic("test failure");
	3247	expect(vec[175] == false) catch @panic("test failure");
	3248	expect(vec[176] == false) catch @panic("test failure");
	3249	expect(vec[177] == true) catch @panic("test failure");
	3250	expect(vec[178] == false) catch @panic("test failure");
	3251	expect(vec[179] == false) catch @panic("test failure");
	3252	expect(vec[180] == false) catch @panic("test failure");
	3253	expect(vec[181] == false) catch @panic("test failure");
	3254	expect(vec[182] == false) catch @panic("test failure");
	3255	expect(vec[183] == false) catch @panic("test failure");
	3256	expect(vec[184] == true) catch @panic("test failure");
	3257	expect(vec[185] == false) catch @panic("test failure");
	3258	expect(vec[186] == false) catch @panic("test failure");
	3259	expect(vec[187] == false) catch @panic("test failure");
	3260	expect(vec[188] == false) catch @panic("test failure");
	3261	expect(vec[189] == true) catch @panic("test failure");
	3262	expect(vec[190] == false) catch @panic("test failure");
	3263	expect(vec[191] == false) catch @panic("test failure");
	3264	expect(vec[192] == false) catch @panic("test failure");
	3265	expect(vec[193] == false) catch @panic("test failure");
	3266	expect(vec[194] == false) catch @panic("test failure");
	3267	expect(vec[195] == false) catch @panic("test failure");
	3268	expect(vec[196] == true) catch @panic("test failure");
	3269	expect(vec[197] == true) catch @panic("test failure");
	3270	expect(vec[198] == true) catch @panic("test failure");
	3271	expect(vec[199] == false) catch @panic("test failure");
	3272	expect(vec[200] == true) catch @panic("test failure");
	3273	expect(vec[201] == true) catch @panic("test failure");
	3274	expect(vec[202] == false) catch @panic("test failure");
	3275	expect(vec[203] == false) catch @panic("test failure");
	3276	expect(vec[204] == false) catch @panic("test failure");
	3277	expect(vec[205] == false) catch @panic("test failure");
	3278	expect(vec[206] == false) catch @panic("test failure");
	3279	expect(vec[207] == true) catch @panic("test failure");
	3280	expect(vec[208] == true) catch @panic("test failure");
	3281	expect(vec[209] == false) catch @panic("test failure");
	3282	expect(vec[210] == false) catch @panic("test failure");
	3283	expect(vec[211] == false) catch @panic("test failure");
	3284	expect(vec[212] == true) catch @panic("test failure");
	3285	expect(vec[213] == false) catch @panic("test failure");
	3286	expect(vec[214] == false) catch @panic("test failure");
	3287	expect(vec[215] == true) catch @panic("test failure");
	3288	expect(vec[216] == true) catch @panic("test failure");
	3289	expect(vec[217] == true) catch @panic("test failure");
	3290	expect(vec[218] == false) catch @panic("test failure");
	3291	expect(vec[219] == false) catch @panic("test failure");
	3292	expect(vec[220] == true) catch @panic("test failure");
	3293	expect(vec[221] == false) catch @panic("test failure");
	3294	expect(vec[222] == true) catch @panic("test failure");
	3295	expect(vec[223] == true) catch @panic("test failure");
	3296	expect(vec[224] == true) catch @panic("test failure");
	3297	expect(vec[225] == true) catch @panic("test failure");
	3298	expect(vec[226] == false) catch @panic("test failure");
	3299	expect(vec[227] == true) catch @panic("test failure");
	3300	expect(vec[228] == false) catch @panic("test failure");
	3301	expect(vec[229] == false) catch @panic("test failure");
	3302	expect(vec[230] == false) catch @panic("test failure");
	3303	expect(vec[231] == true) catch @panic("test failure");
	3304	expect(vec[232] == false) catch @panic("test failure");
	3305	expect(vec[233] == false) catch @panic("test failure");
	3306	expect(vec[234] == false) catch @panic("test failure");
	3307	expect(vec[235] == false) catch @panic("test failure");
	3308	expect(vec[236] == false) catch @panic("test failure");
	3309	expect(vec[237] == false) catch @panic("test failure");
	3310	expect(vec[238] == false) catch @panic("test failure");
	3311	expect(vec[239] == true) catch @panic("test failure");
	3312	expect(vec[240] == false) catch @panic("test failure");
	3313	expect(vec[241] == false) catch @panic("test failure");
	3314	expect(vec[242] == false) catch @panic("test failure");
	3315	expect(vec[243] == true) catch @panic("test failure");
	3316	expect(vec[244] == true) catch @panic("test failure");
	3317	expect(vec[245] == true) catch @panic("test failure");
	3318	expect(vec[246] == true) catch @panic("test failure");
	3319	expect(vec[247] == false) catch @panic("test failure");
	3320	expect(vec[248] == true) catch @panic("test failure");
	3321	expect(vec[249] == true) catch @panic("test failure");
	3322	expect(vec[250] == false) catch @panic("test failure");
	3323	expect(vec[251] == false) catch @panic("test failure");
	3324	expect(vec[252] == false) catch @panic("test failure");
	3325	expect(vec[253] == true) catch @panic("test failure");
	3326	expect(vec[254] == false) catch @panic("test failure");
	3327	expect(vec[255] == false) catch @panic("test failure");
	3328	expect(vec[256] == true) catch @panic("test failure");
	3329	expect(vec[257] == true) catch @panic("test failure");
	3330	expect(vec[258] == false) catch @panic("test failure");
	3331	expect(vec[259] == true) catch @panic("test failure");
	3332	expect(vec[260] == false) catch @panic("test failure");
	3333	expect(vec[261] == true) catch @panic("test failure");
	3334	expect(vec[262] == true) catch @panic("test failure");
	3335	expect(vec[263] == false) catch @panic("test failure");
	3336	expect(vec[264] == false) catch @panic("test failure");
	3337	expect(vec[265] == false) catch @panic("test failure");
	3338	expect(vec[266] == false) catch @panic("test failure");
	3339	expect(vec[267] == true) catch @panic("test failure");
	3340	expect(vec[268] == false) catch @panic("test failure");
	3341	expect(vec[269] == true) catch @panic("test failure");
	3342	expect(vec[270] == true) catch @panic("test failure");
	3343	expect(vec[271] == false) catch @panic("test failure");
	3344	expect(vec[272] == false) catch @panic("test failure");
	3345	expect(vec[273] == true) catch @panic("test failure");
	3346	expect(vec[274] == true) catch @panic("test failure");
	3347	expect(vec[275] == true) catch @panic("test failure");
	3348	expect(vec[276] == false) catch @panic("test failure");
	3349	expect(vec[277] == true) catch @panic("test failure");
	3350	expect(vec[278] == false) catch @panic("test failure");
	3351	expect(vec[279] == false) catch @panic("test failure");
	3352	expect(vec[280] == true) catch @panic("test failure");
	3353	expect(vec[281] == true) catch @panic("test failure");
	3354	expect(vec[282] == false) catch @panic("test failure");
	3355	expect(vec[283] == true) catch @panic("test failure");
	3356	expect(vec[284] == false) catch @panic("test failure");
	3357	expect(vec[285] == true) catch @panic("test failure");
	3358	expect(vec[286] == true) catch @panic("test failure");
	3359	expect(vec[287] == true) catch @panic("test failure");
	3360	expect(vec[288] == true) catch @panic("test failure");
	3361	expect(vec[289] == true) catch @panic("test failure");
	3362	expect(vec[290] == true) catch @panic("test failure");
	3363	expect(vec[291] == true) catch @panic("test failure");
	3364	expect(vec[292] == true) catch @panic("test failure");
	3365	expect(vec[293] == true) catch @panic("test failure");
	3366	expect(vec[294] == true) catch @panic("test failure");
	3367	expect(vec[295] == false) catch @panic("test failure");
	3368	expect(vec[296] == true) catch @panic("test failure");
	3369	expect(vec[297] == false) catch @panic("test failure");
	3370	expect(vec[298] == true) catch @panic("test failure");
	3371	expect(vec[299] == false) catch @panic("test failure");
	3372	expect(vec[300] == true) catch @panic("test failure");
	3373	expect(vec[301] == true) catch @panic("test failure");
	3374	expect(vec[302] == false) catch @panic("test failure");
	3375	expect(vec[303] == true) catch @panic("test failure");
	3376	expect(vec[304] == false) catch @panic("test failure");
	3377	expect(vec[305] == true) catch @panic("test failure");
	3378	expect(vec[306] == false) catch @panic("test failure");
	3379	expect(vec[307] == true) catch @panic("test failure");
	3380	expect(vec[308] == true) catch @panic("test failure");
	3381	expect(vec[309] == false) catch @panic("test failure");
	3382	expect(vec[310] == true) catch @panic("test failure");
	3383	expect(vec[311] == true) catch @panic("test failure");
	3384	expect(vec[312] == true) catch @panic("test failure");
	3385	expect(vec[313] == false) catch @panic("test failure");
	3386	expect(vec[314] == false) catch @panic("test failure");
	3387	expect(vec[315] == false) catch @panic("test failure");
	3388	expect(vec[316] == false) catch @panic("test failure");
	3389	expect(vec[317] == true) catch @panic("test failure");
	3390	expect(vec[318] == true) catch @panic("test failure");
	3391	expect(vec[319] == true) catch @panic("test failure");
	3392	expect(vec[320] == true) catch @panic("test failure");
	3393	expect(vec[321] == true) catch @panic("test failure");
	3394	expect(vec[322] == true) catch @panic("test failure");
	3395	expect(vec[323] == true) catch @panic("test failure");
	3396	expect(vec[324] == true) catch @panic("test failure");
	3397	expect(vec[325] == true) catch @panic("test failure");
	3398	expect(vec[326] == false) catch @panic("test failure");
	3399	expect(vec[327] == true) catch @panic("test failure");
	3400	expect(vec[328] == false) catch @panic("test failure");
	3401	expect(vec[329] == false) catch @panic("test failure");
	3402	expect(vec[330] == true) catch @panic("test failure");
	3403	expect(vec[331] == false) catch @panic("test failure");
	3404	expect(vec[332] == false) catch @panic("test failure");
	3405	expect(vec[333] == false) catch @panic("test failure");
	3406	expect(vec[334] == false) catch @panic("test failure");
	3407	expect(vec[335] == false) catch @panic("test failure");
	3408	expect(vec[336] == false) catch @panic("test failure");
	3409	expect(vec[337] == false) catch @panic("test failure");
	3410	expect(vec[338] == false) catch @panic("test failure");
	3411	expect(vec[339] == false) catch @panic("test failure");
	3412	expect(vec[340] == false) catch @panic("test failure");
	3413	expect(vec[341] == false) catch @panic("test failure");
	3414	expect(vec[342] == true) catch @panic("test failure");
	3415	expect(vec[343] == true) catch @panic("test failure");
	3416	expect(vec[344] == false) catch @panic("test failure");
	3417	expect(vec[345] == false) catch @panic("test failure");
	3418	expect(vec[346] == false) catch @panic("test failure");
	3419	expect(vec[347] == false) catch @panic("test failure");
	3420	expect(vec[348] == false) catch @panic("test failure");
	3421	expect(vec[349] == true) catch @panic("test failure");
	3422	expect(vec[350] == true) catch @panic("test failure");
	3423	expect(vec[351] == true) catch @panic("test failure");
	3424	expect(vec[352] == true) catch @panic("test failure");
	3425	expect(vec[353] == false) catch @panic("test failure");
	3426	expect(vec[354] == false) catch @panic("test failure");
	3427	expect(vec[355] == false) catch @panic("test failure");
	3428	expect(vec[356] == false) catch @panic("test failure");
	3429	expect(vec[357] == true) catch @panic("test failure");
	3430	expect(vec[358] == true) catch @panic("test failure");
	3431	expect(vec[359] == false) catch @panic("test failure");
	3432	expect(vec[360] == false) catch @panic("test failure");
	3433	expect(vec[361] == false) catch @panic("test failure");
	3434	expect(vec[362] == true) catch @panic("test failure");
	3435	expect(vec[363] == true) catch @panic("test failure");
	3436	expect(vec[364] == false) catch @panic("test failure");
	3437	expect(vec[365] == false) catch @panic("test failure");
	3438	expect(vec[366] == false) catch @panic("test failure");
	3439	expect(vec[367] == false) catch @panic("test failure");
	3440	expect(vec[368] == false) catch @panic("test failure");
	3441	expect(vec[369] == true) catch @panic("test failure");
	3442	expect(vec[370] == true) catch @panic("test failure");
	3443	expect(vec[371] == false) catch @panic("test failure");
	3444	expect(vec[372] == true) catch @panic("test failure");
	3445	expect(vec[373] == true) catch @panic("test failure");
	3446	expect(vec[374] == false) catch @panic("test failure");
	3447	expect(vec[375] == true) catch @panic("test failure");
	3448	expect(vec[376] == true) catch @panic("test failure");
	3449	expect(vec[377] == false) catch @panic("test failure");
	3450	expect(vec[378] == true) catch @panic("test failure");
	3451	expect(vec[379] == true) catch @panic("test failure");
	3452	expect(vec[380] == false) catch @panic("test failure");
	3453	expect(vec[381] == true) catch @panic("test failure");
	3454	expect(vec[382] == true) catch @panic("test failure");
	3455	expect(vec[383] == false) catch @panic("test failure");
	3456	expect(vec[384] == true) catch @panic("test failure");
	3457	expect(vec[385] == false) catch @panic("test failure");
	3458	expect(vec[386] == true) catch @panic("test failure");
	3459	expect(vec[387] == true) catch @panic("test failure");
	3460	expect(vec[388] == true) catch @panic("test failure");
	3461	expect(vec[389] == true) catch @panic("test failure");
	3462	expect(vec[390] == false) catch @panic("test failure");
	3463	expect(vec[391] == false) catch @panic("test failure");
	3464	expect(vec[392] == false) catch @panic("test failure");
	3465	expect(vec[393] == true) catch @panic("test failure");
	3466	expect(vec[394] == true) catch @panic("test failure");
	3467	expect(vec[395] == true) catch @panic("test failure");
	3468	expect(vec[396] == true) catch @panic("test failure");
	3469	expect(vec[397] == false) catch @panic("test failure");
	3470	expect(vec[398] == true) catch @panic("test failure");
	3471	expect(vec[399] == true) catch @panic("test failure");
	3472	expect(vec[400] == true) catch @panic("test failure");
	3473	expect(vec[401] == false) catch @panic("test failure");
	3474	expect(vec[402] == false) catch @panic("test failure");
	3475	expect(vec[403] == true) catch @panic("test failure");
	3476	expect(vec[404] == false) catch @panic("test failure");
	3477	expect(vec[405] == false) catch @panic("test failure");
	3478	expect(vec[406] == false) catch @panic("test failure");
	3479	expect(vec[407] == true) catch @panic("test failure");
	3480	expect(vec[408] == true) catch @panic("test failure");
	3481	expect(vec[409] == true) catch @panic("test failure");
	3482	expect(vec[410] == false) catch @panic("test failure");
	3483	expect(vec[411] == true) catch @panic("test failure");
	3484	expect(vec[412] == false) catch @panic("test failure");
	3485	expect(vec[413] == false) catch @panic("test failure");
	3486	expect(vec[414] == false) catch @panic("test failure");
	3487	expect(vec[415] == true) catch @panic("test failure");
	3488	expect(vec[416] == false) catch @panic("test failure");
	3489	expect(vec[417] == false) catch @panic("test failure");
	3490	expect(vec[418] == true) catch @panic("test failure");
	3491	expect(vec[419] == true) catch @panic("test failure");
	3492	expect(vec[420] == true) catch @panic("test failure");
	3493	expect(vec[421] == true) catch @panic("test failure");
	3494	expect(vec[422] == false) catch @panic("test failure");
	3495	expect(vec[423] == true) catch @panic("test failure");
	3496	expect(vec[424] == true) catch @panic("test failure");
	3497	expect(vec[425] == false) catch @panic("test failure");
	3498	expect(vec[426] == false) catch @panic("test failure");
	3499	expect(vec[427] == false) catch @panic("test failure");
	3500	expect(vec[428] == true) catch @panic("test failure");
	3501	expect(vec[429] == false) catch @panic("test failure");
	3502	expect(vec[430] == true) catch @panic("test failure");
	3503	expect(vec[431] == true) catch @panic("test failure");
	3504	expect(vec[432] == false) catch @panic("test failure");
	3505	expect(vec[433] == false) catch @panic("test failure");
	3506	expect(vec[434] == false) catch @panic("test failure");
	3507	expect(vec[435] == false) catch @panic("test failure");
	3508	expect(vec[436] == true) catch @panic("test failure");
	3509	expect(vec[437] == false) catch @panic("test failure");
	3510	expect(vec[438] == true) catch @panic("test failure");
	3511	expect(vec[439] == false) catch @panic("test failure");
	3512	expect(vec[440] == false) catch @panic("test failure");
	3513	expect(vec[441] == false) catch @panic("test failure");
	3514	expect(vec[442] == false) catch @panic("test failure");
	3515	expect(vec[443] == true) catch @panic("test failure");
	3516	expect(vec[444] == false) catch @panic("test failure");
	3517	expect(vec[445] == false) catch @panic("test failure");
	3518	expect(vec[446] == true) catch @panic("test failure");
	3519	expect(vec[447] == true) catch @panic("test failure");
	3520	expect(vec[448] == true) catch @panic("test failure");
	3521	expect(vec[449] == false) catch @panic("test failure");
	3522	expect(vec[450] == true) catch @panic("test failure");
	3523	expect(vec[451] == true) catch @panic("test failure");
	3524	expect(vec[452] == false) catch @panic("test failure");
	3525	expect(vec[453] == true) catch @panic("test failure");
	3526	expect(vec[454] == false) catch @panic("test failure");
	3527	expect(vec[455] == true) catch @panic("test failure");
	3528	expect(vec[456] == false) catch @panic("test failure");
	3529	expect(vec[457] == false) catch @panic("test failure");
	3530	expect(vec[458] == false) catch @panic("test failure");
	3531	expect(vec[459] == true) catch @panic("test failure");
	3532	expect(vec[460] == false) catch @panic("test failure");
	3533	expect(vec[461] == false) catch @panic("test failure");
	3534	expect(vec[462] == false) catch @panic("test failure");
	3535	expect(vec[463] == true) catch @panic("test failure");
	3536	expect(vec[464] == true) catch @panic("test failure");
	3537	expect(vec[465] == true) catch @panic("test failure");
	3538	expect(vec[466] == true) catch @panic("test failure");
	3539	expect(vec[467] == true) catch @panic("test failure");
	3540	expect(vec[468] == false) catch @panic("test failure");
	3541	expect(vec[469] == false) catch @panic("test failure");
	3542	expect(vec[470] == false) catch @panic("test failure");
	3543	expect(vec[471] == false) catch @panic("test failure");
	3544	expect(vec[472] == false) catch @panic("test failure");
	3545	expect(vec[473] == false) catch @panic("test failure");
	3546	expect(vec[474] == true) catch @panic("test failure");
	3547	expect(vec[475] == true) catch @panic("test failure");
	3548	expect(vec[476] == true) catch @panic("test failure");
	3549	expect(vec[477] == true) catch @panic("test failure");
	3550	expect(vec[478] == true) catch @panic("test failure");
	3551	expect(vec[479] == false) catch @panic("test failure");
	3552	expect(vec[480] == true) catch @panic("test failure");
	3553	expect(vec[481] == true) catch @panic("test failure");
	3554	expect(vec[482] == false) catch @panic("test failure");
	3555	expect(vec[483] == true) catch @panic("test failure");
	3556	expect(vec[484] == false) catch @panic("test failure");
	3557	expect(vec[485] == true) catch @panic("test failure");
	3558	expect(vec[486] == false) catch @panic("test failure");
	3559	expect(vec[487] == true) catch @panic("test failure");
	3560	expect(vec[488] == false) catch @panic("test failure");
	3561	expect(vec[489] == false) catch @panic("test failure");
	3562	expect(vec[490] == false) catch @panic("test failure");
	3563	expect(vec[491] == true) catch @panic("test failure");
	3564	expect(vec[492] == false) catch @panic("test failure");
	3565	expect(vec[493] == false) catch @panic("test failure");
	3566	expect(vec[494] == false) catch @panic("test failure");
	3567	expect(vec[495] == true) catch @panic("test failure");
	3568	expect(vec[496] == true) catch @panic("test failure");
	3569	expect(vec[497] == false) catch @panic("test failure");
	3570	expect(vec[498] == false) catch @panic("test failure");
	3571	expect(vec[499] == true) catch @panic("test failure");
	3572	expect(vec[500] == false) catch @panic("test failure");
	3573	expect(vec[501] == true) catch @panic("test failure");
	3574	expect(vec[502] == false) catch @panic("test failure");
	3575	expect(vec[503] == false) catch @panic("test failure");
	3576	expect(vec[504] == false) catch @panic("test failure");
	3577	expect(vec[505] == true) catch @panic("test failure");
	3578	expect(vec[506] == true) catch @panic("test failure");
	3579	expect(vec[507] == true) catch @panic("test failure");
	3580	expect(vec[508] == true) catch @panic("test failure");
	3581	expect(vec[509] == false) catch @panic("test failure");
	3582	expect(vec[510] == false) catch @panic("test failure");
	3583	expect(vec[511] == true) catch @panic("test failure");
	3584	}
5676	3585	};
5677	3586	}
5678	3587	}
5679	3588
5680		const Vector2 = extern struct { x: f32, y: f32 };
	3589	extern fn c_ret_vector_512_bool() @Vector(512, bool);
	3590	extern fn c_vector_512_bool(@Vector(512, bool)) void;
	3591	extern fn c_test_vector_512_bool() void;
	3592
	3593	test "@Vector(512, bool)" {
	3594	if (builtin.zig_backend == .stage2_llvm and (builtin.cpu.arch != .powerpc and builtin.cpu.arch != .wasm32)) return error.SkipZigTest;
	3595
	3596	const vec = c_ret_vector_512_bool();
	3597	try expect(vec[0] == false);
	3598	try expect(vec[1] == true);
	3599	try expect(vec[2] == false);
	3600	try expect(vec[3] == false);
	3601	try expect(vec[4] == false);
	3602	try expect(vec[5] == true);
	3603	try expect(vec[6] == false);
	3604	try expect(vec[7] == false);
	3605	try expect(vec[8] == false);
	3606	try expect(vec[9] == true);
	3607	try expect(vec[10] == false);
	3608	try expect(vec[11] == false);
	3609	try expect(vec[12] == false);
	3610	try expect(vec[13] == true);
	3611	try expect(vec[14] == false);
	3612	try expect(vec[15] == true);
	3613	try expect(vec[16] == false);
	3614	try expect(vec[17] == false);
	3615	try expect(vec[18] == false);
	3616	try expect(vec[19] == false);
	3617	try expect(vec[20] == false);
	3618	try expect(vec[21] == false);
	3619	try expect(vec[22] == true);
	3620	try expect(vec[23] == true);
	3621	try expect(vec[24] == false);
	3622	try expect(vec[25] == false);
	3623	try expect(vec[26] == false);
	3624	try expect(vec[27] == false);
	3625	try expect(vec[28] == true);
	3626	try expect(vec[29] == true);
	3627	try expect(vec[30] == false);
	3628	try expect(vec[31] == true);
	3629	try expect(vec[32] == false);
	3630	try expect(vec[33] == true);
	3631	try expect(vec[34] == true);
	3632	try expect(vec[35] == true);
	3633	try expect(vec[36] == false);
	3634	try expect(vec[37] == false);
	3635	try expect(vec[38] == true);
	3636	try expect(vec[39] == true);
	3637	try expect(vec[40] == false);
	3638	try expect(vec[41] == false);
	3639	try expect(vec[42] == false);
	3640	try expect(vec[43] == false);
	3641	try expect(vec[44] == false);
	3642	try expect(vec[45] == true);
	3643	try expect(vec[46] == false);
	3644	try expect(vec[47] == true);
	3645	try expect(vec[48] == true);
	3646	try expect(vec[49] == false);
	3647	try expect(vec[50] == true);
	3648	try expect(vec[51] == true);
	3649	try expect(vec[52] == true);
	3650	try expect(vec[53] == true);
	3651	try expect(vec[54] == false);
	3652	try expect(vec[55] == false);
	3653	try expect(vec[56] == false);
	3654	try expect(vec[57] == true);
	3655	try expect(vec[58] == true);
	3656	try expect(vec[59] == false);
	3657	try expect(vec[60] == false);
	3658	try expect(vec[61] == false);
	3659	try expect(vec[62] == false);
	3660	try expect(vec[63] == true);
	3661	try expect(vec[64] == true);
	3662	try expect(vec[65] == true);
	3663	try expect(vec[66] == true);
	3664	try expect(vec[67] == true);
	3665	try expect(vec[68] == false);
	3666	try expect(vec[69] == false);
	3667	try expect(vec[70] == false);
	3668	try expect(vec[71] == false);
	3669	try expect(vec[72] == false);
	3670	try expect(vec[73] == true);
	3671	try expect(vec[74] == false);
	3672	try expect(vec[75] == true);
	3673	try expect(vec[76] == false);
	3674	try expect(vec[77] == false);
	3675	try expect(vec[78] == true);
	3676	try expect(vec[79] == true);
	3677	try expect(vec[80] == false);
	3678	try expect(vec[81] == false);
	3679	try expect(vec[82] == false);
	3680	try expect(vec[83] == true);
	3681	try expect(vec[84] == false);
	3682	try expect(vec[85] == true);
	3683	try expect(vec[86] == true);
	3684	try expect(vec[87] == true);
	3685	try expect(vec[88] == false);
	3686	try expect(vec[89] == true);
	3687	try expect(vec[90] == false);
	3688	try expect(vec[91] == false);
	3689	try expect(vec[92] == true);
	3690	try expect(vec[93] == true);
	3691	try expect(vec[94] == false);
	3692	try expect(vec[95] == true);
	3693	try expect(vec[96] == true);
	3694	try expect(vec[97] == false);
	3695	try expect(vec[98] == true);
	3696	try expect(vec[99] == false);
	3697	try expect(vec[100] == true);
	3698	try expect(vec[101] == true);
	3699	try expect(vec[102] == false);
	3700	try expect(vec[103] == true);
	3701	try expect(vec[104] == true);
	3702	try expect(vec[105] == false);
	3703	try expect(vec[106] == false);
	3704	try expect(vec[107] == false);
	3705	try expect(vec[108] == true);
	3706	try expect(vec[109] == false);
	3707	try expect(vec[110] == false);
	3708	try expect(vec[111] == false);
	3709	try expect(vec[112] == true);
	3710	try expect(vec[113] == true);
	3711	try expect(vec[114] == true);
	3712	try expect(vec[115] == false);
	3713	try expect(vec[116] == true);
	3714	try expect(vec[117] == false);
	3715	try expect(vec[118] == true);
	3716	try expect(vec[119] == false);
	3717	try expect(vec[120] == true);
	3718	try expect(vec[121] == true);
	3719	try expect(vec[122] == false);
	3720	try expect(vec[123] == true);
	3721	try expect(vec[124] == false);
	3722	try expect(vec[125] == true);
	3723	try expect(vec[126] == true);
	3724	try expect(vec[127] == true);
	3725	try expect(vec[128] == false);
	3726	try expect(vec[129] == true);
	3727	try expect(vec[130] == false);
	3728	try expect(vec[131] == false);
	3729	try expect(vec[132] == false);
	3730	try expect(vec[133] == false);
	3731	try expect(vec[134] == false);
	3732	try expect(vec[135] == false);
	3733	try expect(vec[136] == true);
	3734	try expect(vec[137] == false);
	3735	try expect(vec[138] == true);
	3736	try expect(vec[139] == false);
	3737	try expect(vec[140] == true);
	3738	try expect(vec[141] == true);
	3739	try expect(vec[142] == false);
	3740	try expect(vec[143] == true);
	3741	try expect(vec[144] == false);
	3742	try expect(vec[145] == false);
	3743	try expect(vec[146] == true);
	3744	try expect(vec[147] == false);
	3745	try expect(vec[148] == false);
	3746	try expect(vec[149] == true);
	3747	try expect(vec[150] == false);
	3748	try expect(vec[151] == true);
	3749	try expect(vec[152] == false);
	3750	try expect(vec[153] == true);
	3751	try expect(vec[154] == false);
	3752	try expect(vec[155] == false);
	3753	try expect(vec[156] == true);
	3754	try expect(vec[157] == false);
	3755	try expect(vec[158] == true);
	3756	try expect(vec[159] == true);
	3757	try expect(vec[160] == true);
	3758	try expect(vec[161] == false);
	3759	try expect(vec[162] == false);
	3760	try expect(vec[163] == true);
	3761	try expect(vec[164] == false);
	3762	try expect(vec[165] == false);
	3763	try expect(vec[166] == false);
	3764	try expect(vec[167] == true);
	3765	try expect(vec[168] == true);
	3766	try expect(vec[169] == true);
	3767	try expect(vec[170] == false);
	3768	try expect(vec[171] == true);
	3769	try expect(vec[172] == false);
	3770	try expect(vec[173] == false);
	3771	try expect(vec[174] == false);
	3772	try expect(vec[175] == false);
	3773	try expect(vec[176] == false);
	3774	try expect(vec[177] == true);
	3775	try expect(vec[178] == true);
	3776	try expect(vec[179] == false);
	3777	try expect(vec[180] == false);
	3778	try expect(vec[181] == true);
	3779	try expect(vec[182] == false);
	3780	try expect(vec[183] == false);
	3781	try expect(vec[184] == false);
	3782	try expect(vec[185] == false);
	3783	try expect(vec[186] == false);
	3784	try expect(vec[187] == true);
	3785	try expect(vec[188] == true);
	3786	try expect(vec[189] == false);
	3787	try expect(vec[190] == false);
	3788	try expect(vec[191] == false);
	3789	try expect(vec[192] == false);
	3790	try expect(vec[193] == false);
	3791	try expect(vec[194] == false);
	3792	try expect(vec[195] == true);
	3793	try expect(vec[196] == true);
	3794	try expect(vec[197] == false);
	3795	try expect(vec[198] == true);
	3796	try expect(vec[199] == true);
	3797	try expect(vec[200] == true);
	3798	try expect(vec[201] == true);
	3799	try expect(vec[202] == true);
	3800	try expect(vec[203] == true);
	3801	try expect(vec[204] == false);
	3802	try expect(vec[205] == false);
	3803	try expect(vec[206] == false);
	3804	try expect(vec[207] == false);
	3805	try expect(vec[208] == true);
	3806	try expect(vec[209] == false);
	3807	try expect(vec[210] == true);
	3808	try expect(vec[211] == true);
	3809	try expect(vec[212] == true);
	3810	try expect(vec[213] == true);
	3811	try expect(vec[214] == false);
	3812	try expect(vec[215] == false);
	3813	try expect(vec[216] == false);
	3814	try expect(vec[217] == true);
	3815	try expect(vec[218] == true);
	3816	try expect(vec[219] == false);
	3817	try expect(vec[220] == true);
	3818	try expect(vec[221] == true);
	3819	try expect(vec[222] == false);
	3820	try expect(vec[223] == false);
	3821	try expect(vec[224] == false);
	3822	try expect(vec[225] == true);
	3823	try expect(vec[226] == true);
	3824	try expect(vec[227] == true);
	3825	try expect(vec[228] == true);
	3826	try expect(vec[229] == false);
	3827	try expect(vec[230] == true);
	3828	try expect(vec[231] == false);
	3829	try expect(vec[232] == true);
	3830	try expect(vec[233] == true);
	3831	try expect(vec[234] == true);
	3832	try expect(vec[235] == true);
	3833	try expect(vec[236] == false);
	3834	try expect(vec[237] == true);
	3835	try expect(vec[238] == false);
	3836	try expect(vec[239] == true);
	3837	try expect(vec[240] == false);
	3838	try expect(vec[241] == true);
	3839	try expect(vec[242] == false);
	3840	try expect(vec[243] == false);
	3841	try expect(vec[244] == false);
	3842	try expect(vec[245] == true);
	3843	try expect(vec[246] == true);
	3844	try expect(vec[247] == false);
	3845	try expect(vec[248] == true);
	3846	try expect(vec[249] == false);
	3847	try expect(vec[250] == false);
	3848	try expect(vec[251] == false);
	3849	try expect(vec[252] == true);
	3850	try expect(vec[253] == true);
	3851	try expect(vec[254] == true);
	3852	try expect(vec[255] == true);
	3853	try expect(vec[256] == true);
	3854	try expect(vec[257] == false);
	3855	try expect(vec[258] == true);
	3856	try expect(vec[259] == true);
	3857	try expect(vec[260] == true);
	3858	try expect(vec[261] == true);
	3859	try expect(vec[262] == false);
	3860	try expect(vec[263] == true);
	3861	try expect(vec[264] == false);
	3862	try expect(vec[265] == false);
	3863	try expect(vec[266] == true);
	3864	try expect(vec[267] == false);
	3865	try expect(vec[268] == true);
	3866	try expect(vec[269] == false);
	3867	try expect(vec[270] == false);
	3868	try expect(vec[271] == true);
	3869	try expect(vec[272] == true);
	3870	try expect(vec[273] == false);
	3871	try expect(vec[274] == true);
	3872	try expect(vec[275] == false);
	3873	try expect(vec[276] == false);
	3874	try expect(vec[277] == true);
	3875	try expect(vec[278] == false);
	3876	try expect(vec[279] == false);
	3877	try expect(vec[280] == true);
	3878	try expect(vec[281] == true);
	3879	try expect(vec[282] == true);
	3880	try expect(vec[283] == false);
	3881	try expect(vec[284] == false);
	3882	try expect(vec[285] == true);
	3883	try expect(vec[286] == true);
	3884	try expect(vec[287] == true);
	3885	try expect(vec[288] == false);
	3886	try expect(vec[289] == false);
	3887	try expect(vec[290] == false);
	3888	try expect(vec[291] == false);
	3889	try expect(vec[292] == false);
	3890	try expect(vec[293] == false);
	3891	try expect(vec[294] == true);
	3892	try expect(vec[295] == false);
	3893	try expect(vec[296] == true);
	3894	try expect(vec[297] == false);
	3895	try expect(vec[298] == true);
	3896	try expect(vec[299] == true);
	3897	try expect(vec[300] == false);
	3898	try expect(vec[301] == false);
	3899	try expect(vec[302] == false);
	3900	try expect(vec[303] == false);
	3901	try expect(vec[304] == true);
	3902	try expect(vec[305] == true);
	3903	try expect(vec[306] == true);
	3904	try expect(vec[307] == true);
	3905	try expect(vec[308] == true);
	3906	try expect(vec[309] == false);
	3907	try expect(vec[310] == true);
	3908	try expect(vec[311] == true);
	3909	try expect(vec[312] == true);
	3910	try expect(vec[313] == true);
	3911	try expect(vec[314] == true);
	3912	try expect(vec[315] == false);
	3913	try expect(vec[316] == true);
	3914	try expect(vec[317] == true);
	3915	try expect(vec[318] == true);
	3916	try expect(vec[319] == false);
	3917	try expect(vec[320] == true);
	3918	try expect(vec[321] == false);
	3919	try expect(vec[322] == true);
	3920	try expect(vec[323] == true);
	3921	try expect(vec[324] == true);
	3922	try expect(vec[325] == false);
	3923	try expect(vec[326] == false);
	3924	try expect(vec[327] == true);
	3925	try expect(vec[328] == true);
	3926	try expect(vec[329] == true);
	3927	try expect(vec[330] == false);
	3928	try expect(vec[331] == false);
	3929	try expect(vec[332] == true);
	3930	try expect(vec[333] == true);
	3931	try expect(vec[334] == false);
	3932	try expect(vec[335] == true);
	3933	try expect(vec[336] == true);
	3934	try expect(vec[337] == true);
	3935	try expect(vec[338] == true);
	3936	try expect(vec[339] == true);
	3937	try expect(vec[340] == true);
	3938	try expect(vec[341] == false);
	3939	try expect(vec[342] == true);
	3940	try expect(vec[343] == false);
	3941	try expect(vec[344] == true);
	3942	try expect(vec[345] == false);
	3943	try expect(vec[346] == false);
	3944	try expect(vec[347] == false);
	3945	try expect(vec[348] == false);
	3946	try expect(vec[349] == true);
	3947	try expect(vec[350] == true);
	3948	try expect(vec[351] == true);
	3949	try expect(vec[352] == true);
	3950	try expect(vec[353] == false);
	3951	try expect(vec[354] == true);
	3952	try expect(vec[355] == false);
	3953	try expect(vec[356] == true);
	3954	try expect(vec[357] == true);
	3955	try expect(vec[358] == false);
	3956	try expect(vec[359] == true);
	3957	try expect(vec[360] == false);
	3958	try expect(vec[361] == false);
	3959	try expect(vec[362] == true);
	3960	try expect(vec[363] == false);
	3961	try expect(vec[364] == false);
	3962	try expect(vec[365] == false);
	3963	try expect(vec[366] == false);
	3964	try expect(vec[367] == false);
	3965	try expect(vec[368] == false);
	3966	try expect(vec[369] == false);
	3967	try expect(vec[370] == true);
	3968	try expect(vec[371] == false);
	3969	try expect(vec[372] == true);
	3970	try expect(vec[373] == true);
	3971	try expect(vec[374] == false);
	3972	try expect(vec[375] == false);
	3973	try expect(vec[376] == true);
	3974	try expect(vec[377] == false);
	3975	try expect(vec[378] == false);
	3976	try expect(vec[379] == true);
	3977	try expect(vec[380] == false);
	3978	try expect(vec[381] == false);
	3979	try expect(vec[382] == true);
	3980	try expect(vec[383] == false);
	3981	try expect(vec[384] == false);
	3982	try expect(vec[385] == false);
	3983	try expect(vec[386] == false);
	3984	try expect(vec[387] == true);
	3985	try expect(vec[388] == true);
	3986	try expect(vec[389] == true);
	3987	try expect(vec[390] == true);
	3988	try expect(vec[391] == true);
	3989	try expect(vec[392] == true);
	3990	try expect(vec[393] == true);
	3991	try expect(vec[394] == false);
	3992	try expect(vec[395] == true);
	3993	try expect(vec[396] == true);
	3994	try expect(vec[397] == false);
	3995	try expect(vec[398] == false);
	3996	try expect(vec[399] == false);
	3997	try expect(vec[400] == true);
	3998	try expect(vec[401] == false);
	3999	try expect(vec[402] == true);
	4000	try expect(vec[403] == true);
	4001	try expect(vec[404] == false);
	4002	try expect(vec[405] == true);
	4003	try expect(vec[406] == true);
	4004	try expect(vec[407] == true);
	4005	try expect(vec[408] == true);
	4006	try expect(vec[409] == false);
	4007	try expect(vec[410] == false);
	4008	try expect(vec[411] == false);
	4009	try expect(vec[412] == true);
	4010	try expect(vec[413] == true);
	4011	try expect(vec[414] == false);
	4012	try expect(vec[415] == true);
	4013	try expect(vec[416] == false);
	4014	try expect(vec[417] == true);
	4015	try expect(vec[418] == false);
	4016	try expect(vec[419] == false);
	4017	try expect(vec[420] == false);
	4018	try expect(vec[421] == false);
	4019	try expect(vec[422] == true);
	4020	try expect(vec[423] == true);
	4021	try expect(vec[424] == true);
	4022	try expect(vec[425] == false);
	4023	try expect(vec[426] == true);
	4024	try expect(vec[427] == false);
	4025	try expect(vec[428] == false);
	4026	try expect(vec[429] == false);
	4027	try expect(vec[430] == true);
	4028	try expect(vec[431] == true);
	4029	try expect(vec[432] == false);
	4030	try expect(vec[433] == true);
	4031	try expect(vec[434] == false);
	4032	try expect(vec[435] == false);
	4033	try expect(vec[436] == true);
	4034	try expect(vec[437] == true);
	4035	try expect(vec[438] == true);
	4036	try expect(vec[439] == true);
	4037	try expect(vec[440] == true);
	4038	try expect(vec[441] == true);
	4039	try expect(vec[442] == false);
	4040	try expect(vec[443] == false);
	4041	try expect(vec[444] == false);
	4042	try expect(vec[445] == true);
	4043	try expect(vec[446] == true);
	4044	try expect(vec[447] == true);
	4045	try expect(vec[448] == false);
	4046	try expect(vec[449] == false);
	4047	try expect(vec[450] == false);
	4048	try expect(vec[451] == false);
	4049	try expect(vec[452] == false);
	4050	try expect(vec[453] == false);
	4051	try expect(vec[454] == false);
	4052	try expect(vec[455] == false);
	4053	try expect(vec[456] == false);
	4054	try expect(vec[457] == false);
	4055	try expect(vec[458] == false);
	4056	try expect(vec[459] == true);
	4057	try expect(vec[460] == false);
	4058	try expect(vec[461] == false);
	4059	try expect(vec[462] == false);
	4060	try expect(vec[463] == true);
	4061	try expect(vec[464] == false);
	4062	try expect(vec[465] == false);
	4063	try expect(vec[466] == false);
	4064	try expect(vec[467] == false);
	4065	try expect(vec[468] == true);
	4066	try expect(vec[469] == true);
	4067	try expect(vec[470] == true);
	4068	try expect(vec[471] == true);
	4069	try expect(vec[472] == true);
	4070	try expect(vec[473] == false);
	4071	try expect(vec[474] == false);
	4072	try expect(vec[475] == true);
	4073	try expect(vec[476] == true);
	4074	try expect(vec[477] == true);
	4075	try expect(vec[478] == false);
	4076	try expect(vec[479] == true);
	4077	try expect(vec[480] == true);
	4078	try expect(vec[481] == true);
	4079	try expect(vec[482] == false);
	4080	try expect(vec[483] == true);
	4081	try expect(vec[484] == false);
	4082	try expect(vec[485] == true);
	4083	try expect(vec[486] == false);
	4084	try expect(vec[487] == true);
	4085	try expect(vec[488] == false);
	4086	try expect(vec[489] == true);
	4087	try expect(vec[490] == true);
	4088	try expect(vec[491] == true);
	4089	try expect(vec[492] == true);
	4090	try expect(vec[493] == false);
	4091	try expect(vec[494] == true);
	4092	try expect(vec[495] == true);
	4093	try expect(vec[496] == false);
	4094	try expect(vec[497] == true);
	4095	try expect(vec[498] == false);
	4096	try expect(vec[499] == false);
	4097	try expect(vec[500] == false);
	4098	try expect(vec[501] == false);
	4099	try expect(vec[502] == false);
	4100	try expect(vec[503] == false);
	4101	try expect(vec[504] == false);
	4102	try expect(vec[505] == false);
	4103	try expect(vec[506] == false);
	4104	try expect(vec[507] == true);
	4105	try expect(vec[508] == true);
	4106	try expect(vec[509] == false);
	4107	try expect(vec[510] == true);
	4108	try expect(vec[511] == false);
	4109	if (!builtin.target.cpu.arch.isWasm()) c_vector_512_bool(.{
	4110	true,
	4111	true,
	4112	true,
	4113	true,
	4114	true,
	4115	false,
	4116	false,
	4117	true,
	4118	true,
	4119	true,
	4120	true,
	4121	false,
	4122	true,
	4123	true,
	4124	false,
	4125	false,
	4126	false,
	4127	true,
	4128	true,
	4129	true,
	4130	true,
	4131	true,
	4132	false,
	4133	false,
	4134	true,
	4135	true,
	4136	false,
	4137	false,
	4138	false,
	4139	false,
	4140	false,
	4141	true,
	4142	true,
	4143	false,
	4144	true,
	4145	true,
	4146	true,
	4147	true,
	4148	true,
	4149	true,
	4150	false,
	4151	true,
	4152	true,
	4153	false,
	4154	false,
	4155	false,
	4156	true,
	4157	true,
	4158	false,
	4159	true,
	4160	false,
	4161	true,
	4162	true,
	4163	false,
	4164	true,
	4165	false,
	4166	false,
	4167	true,
	4168	true,
	4169	false,
	4170	true,
	4171	true,
	4172	false,
	4173	true,
	4174	false,
	4175	true,
	4176	true,
	4177	true,
	4178	true,
	4179	true,
	4180	true,
	4181	true,
	4182	true,
	4183	true,
	4184	false,
	4185	true,
	4186	false,
	4187	true,
	4188	false,
	4189	false,
	4190	false,
	4191	true,
	4192	false,
	4193	true,
	4194	true,
	4195	false,
	4196	true,
	4197	true,
	4198	true,
	4199	false,
	4200	true,
	4201	true,
	4202	false,
	4203	true,
	4204	false,
	4205	true,
	4206	true,
	4207	false,
	4208	false,
	4209	false,
	4210	true,
	4211	true,
	4212	false,
	4213	true,
	4214	false,
	4215	false,
	4216	true,
	4217	false,
	4218	false,
	4219	true,
	4220	false,
	4221	false,
	4222	false,
	4223	false,
	4224	false,
	4225	true,
	4226	true,
	4227	false,
	4228	false,
	4229	false,
	4230	false,
	4231	true,
	4232	false,
	4233	false,
	4234	true,
	4235	true,
	4236	false,
	4237	true,
	4238	false,
	4239	true,
	4240	true,
	4241	false,
	4242	true,
	4243	false,
	4244	false,
	4245	false,
	4246	false,
	4247	true,
	4248	true,
	4249	false,
	4250	false,
	4251	false,
	4252	true,
	4253	true,
	4254	false,
	4255	false,
	4256	true,
	4257	true,
	4258	true,
	4259	true,
	4260	true,
	4261	true,
	4262	true,
	4263	false,
	4264	true,
	4265	false,
	4266	false,
	4267	true,
	4268	false,
	4269	true,
	4270	false,
	4271	true,
	4272	true,
	4273	true,
	4274	true,
	4275	true,
	4276	true,
	4277	true,
	4278	true,
	4279	false,
	4280	true,
	4281	true,
	4282	false,
	4283	true,
	4284	true,
	4285	false,
	4286	false,
	4287	false,
	4288	true,
	4289	false,
	4290	false,
	4291	true,
	4292	true,
	4293	true,
	4294	true,
	4295	true,
	4296	true,
	4297	true,
	4298	true,
	4299	true,
	4300	false,
	4301	true,
	4302	true,
	4303	false,
	4304	false,
	4305	true,
	4306	true,
	4307	false,
	4308	true,
	4309	true,
	4310	false,
	4311	true,
	4312	true,
	4313	false,
	4314	true,
	4315	true,
	4316	true,
	4317	true,
	4318	false,
	4319	true,
	4320	false,
	4321	true,
	4322	true,
	4323	false,
	4324	true,
	4325	false,
	4326	true,
	4327	false,
	4328	true,
	4329	false,
	4330	false,
	4331	true,
	4332	false,
	4333	false,
	4334	false,
	4335	true,
	4336	true,
	4337	false,
	4338	false,
	4339	false,
	4340	true,
	4341	false,
	4342	true,
	4343	false,
	4344	false,
	4345	false,
	4346	true,
	4347	true,
	4348	false,
	4349	false,
	4350	false,
	4351	false,
	4352	false,
	4353	true,
	4354	true,
	4355	false,
	4356	true,
	4357	false,
	4358	false,
	4359	true,
	4360	false,
	4361	false,
	4362	false,
	4363	true,
	4364	false,
	4365	false,
	4366	false,
	4367	false,
	4368	true,
	4369	true,
	4370	true,
	4371	true,
	4372	false,
	4373	true,
	4374	false,
	4375	false,
	4376	false,
	4377	true,
	4378	false,
	4379	false,
	4380	true,
	4381	true,
	4382	false,
	4383	false,
	4384	false,
	4385	false,
	4386	false,
	4387	true,
	4388	false,
	4389	true,
	4390	true,
	4391	true,
	4392	true,
	4393	true,
	4394	false,
	4395	false,
	4396	false,
	4397	false,
	4398	false,
	4399	false,
	4400	false,
	4401	false,
	4402	false,
	4403	true,
	4404	true,
	4405	true,
	4406	true,
	4407	true,
	4408	true,
	4409	false,
	4410	true,
	4411	false,
	4412	true,
	4413	true,
	4414	true,
	4415	false,
	4416	false,
	4417	true,
	4418	true,
	4419	true,
	4420	false,
	4421	true,
	4422	true,
	4423	true,
	4424	false,
	4425	true,
	4426	true,
	4427	true,
	4428	false,
	4429	true,
	4430	true,
	4431	false,
	4432	false,
	4433	true,
	4434	false,
	4435	false,
	4436	false,
	4437	false,
	4438	true,
	4439	false,
	4440	true,
	4441	true,
	4442	true,
	4443	true,
	4444	false,
	4445	false,
	4446	true,
	4447	false,
	4448	true,
	4449	false,
	4450	false,
	4451	false,
	4452	true,
	4453	false,
	4454	true,
	4455	false,
	4456	false,
	4457	true,
	4458	true,
	4459	true,
	4460	true,
	4461	false,
	4462	false,
	4463	false,
	4464	true,
	4465	true,
	4466	false,
	4467	true,
	4468	false,
	4469	false,
	4470	true,
	4471	false,
	4472	true,
	4473	false,
	4474	true,
	4475	true,
	4476	false,
	4477	false,
	4478	true,
	4479	true,
	4480	true,
	4481	true,
	4482	false,
	4483	false,
	4484	true,
	4485	false,
	4486	true,
	4487	true,
	4488	false,
	4489	true,
	4490	true,
	4491	false,
	4492	true,
	4493	true,
	4494	true,
	4495	false,
	4496	true,
	4497	true,
	4498	true,
	4499	false,
	4500	false,
	4501	true,
	4502	false,
	4503	true,
	4504	true,
	4505	true,
	4506	false,
	4507	false,
	4508	false,
	4509	false,
	4510	false,
	4511	true,
	4512	false,
	4513	false,
	4514	false,
	4515	false,
	4516	true,
	4517	false,
	4518	false,
	4519	true,
	4520	true,
	4521	false,
	4522	false,
	4523	false,
	4524	false,
	4525	true,
	4526	true,
	4527	true,
	4528	true,
	4529	true,
	4530	false,
	4531	false,
	4532	false,
	4533	true,
	4534	false,
	4535	false,
	4536	false,
	4537	false,
	4538	true,
	4539	false,
	4540	true,
	4541	false,
	4542	true,
	4543	true,
	4544	true,
	4545	true,
	4546	false,
	4547	false,
	4548	false,
	4549	false,
	4550	false,
	4551	true,
	4552	true,
	4553	true,
	4554	true,
	4555	true,
	4556	true,
	4557	true,
	4558	true,
	4559	true,
	4560	false,
	4561	false,
	4562	true,
	4563	false,
	4564	true,
	4565	false,
	4566	false,
	4567	true,
	4568	false,
	4569	false,
	4570	true,
	4571	true,
	4572	true,
	4573	true,
	4574	true,
	4575	true,
	4576	false,
	4577	true,
	4578	false,
	4579	false,
	4580	false,
	4581	true,
	4582	true,
	4583	false,
	4584	true,
	4585	true,
	4586	false,
	4587	false,
	4588	true,
	4589	true,
	4590	false,
	4591	false,
	4592	true,
	4593	true,
	4594	false,
	4595	true,
	4596	false,
	4597	true,
	4598	true,
	4599	true,
	4600	true,
	4601	true,
	4602	true,
	4603	true,
	4604	true,
	4605	true,
	4606	false,
	4607	true,
	4608	true,
	4609	true,
	4610	false,
	4611	false,
	4612	true,
	4613	false,
	4614	false,
	4615	false,
	4616	true,
	4617	true,
	4618	false,
	4619	true,
	4620	false,
	4621	true,
	4622	});
	4623	c_test_vector_512_bool();
	4624	}
	4625
	4626	export fn zig_ret_vector_1_u8() @Vector(1, u8) {
	4627	return .{1};
	4628	}
	4629	export fn zig_vector_1_u8(v: @Vector(1, u8), i: usize) void {
	4630	expect(v[0] == 2) catch @panic("test failure");
	4631	expect(i == 1) catch @panic("test failure");
	4632	}
	4633
	4634	extern fn c_ret_vector_1_u8() @Vector(1, u8);
	4635	extern fn c_vector_1_u8(@Vector(1, u8), usize) void;
	4636	extern fn c_test_vector_1_u8() void;
	4637
	4638	test "@Vector(1, u8)" {
	4639	if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
	4640	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	4641	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	4642
	4643	const v = c_ret_vector_1_u8();
	4644	try expect(v[0] == 3);
	4645	c_vector_1_u8(.{4}, 1);
	4646	c_test_vector_1_u8();
	4647	}
	4648
	4649	export fn zig_ret_vector_2_u8() @Vector(2, u8) {
	4650	return .{ 5, 6 };
	4651	}
	4652	export fn zig_vector_2_u8(v: @Vector(2, u8), i: usize) void {
	4653	expect(v[0] == 7) catch @panic("test failure");
	4654	expect(v[1] == 8) catch @panic("test failure");
	4655	expect(i == 2) catch @panic("test failure");
	4656	}
	4657
	4658	extern fn c_ret_vector_2_u8() @Vector(2, u8);
	4659	extern fn c_vector_2_u8(@Vector(2, u8), usize) void;
	4660	extern fn c_test_vector_2_u8() void;
	4661
	4662	test "@Vector(2, u8)" {
	4663	if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
	4664	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	4665	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	4666	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	4667	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	4668	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) return error.SkipZigTest;
	4669
	4670	const v = c_ret_vector_2_u8();
	4671	try expect(v[0] == 9);
	4672	try expect(v[1] == 10);
	4673	c_vector_2_u8(.{ 11, 12 }, 2);
	4674	c_test_vector_2_u8();
	4675	}
	4676
	4677	export fn zig_ret_vector_3_u8() @Vector(3, u8) {
	4678	return .{ 13, 14, 15 };
	4679	}
	4680	export fn zig_vector_3_u8(v: @Vector(3, u8), i: usize) void {
	4681	expect(v[0] == 16) catch @panic("test failure");
	4682	expect(v[1] == 17) catch @panic("test failure");
	4683	expect(v[2] == 18) catch @panic("test failure");
	4684	expect(i == 3) catch @panic("test failure");
	4685	}
	4686
	4687	extern fn c_ret_vector_3_u8() @Vector(3, u8);
	4688	extern fn c_vector_3_u8(@Vector(3, u8), usize) void;
	4689	extern fn c_test_vector_3_u8() void;
	4690
	4691	test "@Vector(3, u8)" {
	4692	if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
	4693	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	4694	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	4695	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	4696	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	4697	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag != .windows) return error.SkipZigTest;
	4698
	4699	const v = c_ret_vector_3_u8();
	4700	try expect(v[0] == 19);
	4701	try expect(v[1] == 20);
	4702	try expect(v[2] == 21);
	4703	c_vector_3_u8(.{ 22, 23, 24 }, 3);
	4704	c_test_vector_3_u8();
	4705	}
	4706
	4707	export fn zig_ret_vector_4_u8() @Vector(4, u8) {
	4708	return .{ 25, 26, 27, 28 };
	4709	}
	4710	export fn zig_vector_4_u8(v: @Vector(4, u8), i: usize) void {
	4711	expect(v[0] == 29) catch @panic("test failure");
	4712	expect(v[1] == 30) catch @panic("test failure");
	4713	expect(v[2] == 31) catch @panic("test failure");
	4714	expect(v[3] == 32) catch @panic("test failure");
	4715	expect(i == 4) catch @panic("test failure");
	4716	}
	4717	export fn zig_vector_4_u8_vector_4_u8(v0: @Vector(4, u8), v1: @Vector(4, u8), i: usize) void {
	4718	expect(v0[0] == 33) catch @panic("test failure");
	4719	expect(v0[1] == 34) catch @panic("test failure");
	4720	expect(v0[2] == 35) catch @panic("test failure");
	4721	expect(v0[3] == 36) catch @panic("test failure");
	4722	expect(v1[0] == 37) catch @panic("test failure");
	4723	expect(v1[1] == 38) catch @panic("test failure");
	4724	expect(v1[2] == 39) catch @panic("test failure");
	4725	expect(v1[3] == 40) catch @panic("test failure");
	4726	expect(i == 8) catch @panic("test failure");
	4727	}
	4728
	4729	extern fn c_ret_vector_4_u8() @Vector(4, u8);
	4730	extern fn c_vector_4_u8(@Vector(4, u8), usize) void;
	4731	extern fn c_vector_4_u8_vector_4_u8(@Vector(4, u8), @Vector(4, u8), usize) void;
	4732	extern fn c_test_vector_4_u8() void;
	4733
	4734	test "@Vector(4, u8)" {
	4735	if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
	4736	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	4737	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	4738	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	4739	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	4740	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) return error.SkipZigTest;
	4741
	4742	const v = c_ret_vector_4_u8();
	4743	try expect(v[0] == 41);
	4744	try expect(v[1] == 42);
	4745	try expect(v[2] == 43);
	4746	try expect(v[3] == 44);
	4747	c_vector_4_u8(.{ 45, 46, 47, 48 }, 4);
	4748	c_vector_4_u8_vector_4_u8(.{ 49, 50, 51, 52 }, .{ 53, 54, 55, 56 }, 8);
	4749	c_test_vector_4_u8();
	4750	}
	4751
	4752	export fn zig_ret_vector_6_u8() @Vector(6, u8) {
	4753	return .{ 41, 42, 43, 44, 45, 46 };
	4754	}
	4755	export fn zig_vector_6_u8(v: @Vector(6, u8), i: usize) void {
	4756	expect(v[0] == 47) catch @panic("test failure");
	4757	expect(v[1] == 48) catch @panic("test failure");
	4758	expect(v[2] == 49) catch @panic("test failure");
	4759	expect(v[3] == 50) catch @panic("test failure");
	4760	expect(v[4] == 51) catch @panic("test failure");
	4761	expect(v[5] == 52) catch @panic("test failure");
	4762	expect(i == 6) catch @panic("test failure");
	4763	}
	4764
	4765	extern fn c_ret_vector_6_u8() @Vector(6, u8);
	4766	extern fn c_vector_6_u8(@Vector(6, u8), usize) void;
	4767	extern fn c_test_vector_6_u8() void;
	4768
	4769	test "@Vector(6, u8)" {
	4770	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	4771	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	4772	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	4773	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	4774	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag != .windows) return error.SkipZigTest;
	4775
	4776	const v = c_ret_vector_6_u8();
	4777	try expect(v[0] == 53);
	4778	try expect(v[1] == 54);
	4779	try expect(v[2] == 55);
	4780	try expect(v[3] == 56);
	4781	try expect(v[4] == 57);
	4782	try expect(v[5] == 58);
	4783	c_vector_6_u8(.{ 59, 60, 61, 62, 63, 64 }, 6);
	4784	c_test_vector_6_u8();
	4785	}
	4786
	4787	export fn zig_ret_vector_8_u8() @Vector(8, u8) {
	4788	return .{ 65, 66, 67, 68, 69, 70, 71, 72 };
	4789	}
	4790	export fn zig_vector_8_u8(v: @Vector(8, u8), i: usize) void {
	4791	expect(v[0] == 73) catch @panic("test failure");
	4792	expect(v[1] == 74) catch @panic("test failure");
	4793	expect(v[2] == 75) catch @panic("test failure");
	4794	expect(v[3] == 76) catch @panic("test failure");
	4795	expect(v[4] == 77) catch @panic("test failure");
	4796	expect(v[5] == 78) catch @panic("test failure");
	4797	expect(v[6] == 79) catch @panic("test failure");
	4798	expect(v[7] == 80) catch @panic("test failure");
	4799	expect(i == 8) catch @panic("test failure");
	4800	}
	4801
	4802	extern fn c_ret_vector_8_u8() @Vector(8, u8);
	4803	extern fn c_vector_8_u8(@Vector(8, u8), usize) void;
	4804	extern fn c_test_vector_8_u8() void;
	4805
	4806	test "@Vector(8, u8)" {
	4807	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	4808	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	4809	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	4810	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
	4811
	4812	const v = c_ret_vector_8_u8();
	4813	try expect(v[0] == 81);
	4814	try expect(v[1] == 82);
	4815	try expect(v[2] == 83);
	4816	try expect(v[3] == 84);
	4817	try expect(v[4] == 85);
	4818	try expect(v[5] == 86);
	4819	try expect(v[6] == 87);
	4820	try expect(v[7] == 88);
	4821	c_vector_8_u8(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8);
	4822	c_test_vector_8_u8();
	4823	}
	4824
	4825	export fn zig_ret_vector_12_u8() @Vector(12, u8) {
	4826	return .{ 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8 };
	4827	}
	4828	export fn zig_vector_12_u8(v: @Vector(12, u8), i: usize) void {
	4829	expect(v[0] == 9) catch @panic("test failure");
	4830	expect(v[1] == 10) catch @panic("test failure");
	4831	expect(v[2] == 11) catch @panic("test failure");
	4832	expect(v[3] == 12) catch @panic("test failure");
	4833	expect(v[4] == 13) catch @panic("test failure");
	4834	expect(v[5] == 14) catch @panic("test failure");
	4835	expect(v[6] == 15) catch @panic("test failure");
	4836	expect(v[7] == 16) catch @panic("test failure");
	4837	expect(v[8] == 17) catch @panic("test failure");
	4838	expect(v[9] == 18) catch @panic("test failure");
	4839	expect(v[10] == 19) catch @panic("test failure");
	4840	expect(v[11] == 20) catch @panic("test failure");
	4841	expect(i == 12) catch @panic("test failure");
	4842	}
	4843
	4844	extern fn c_ret_vector_12_u8() @Vector(12, u8);
	4845	extern fn c_vector_12_u8(@Vector(12, u8), usize) void;
	4846	extern fn c_test_vector_12_u8() void;
	4847
	4848	test "@Vector(12, u8)" {
	4849	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	4850	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	4851	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	4852
	4853	const v = c_ret_vector_12_u8();
	4854	try expect(v[0] == 21);
	4855	try expect(v[1] == 22);
	4856	try expect(v[2] == 23);
	4857	try expect(v[3] == 24);
	4858	try expect(v[4] == 25);
	4859	try expect(v[5] == 26);
	4860	try expect(v[6] == 27);
	4861	try expect(v[7] == 28);
	4862	try expect(v[8] == 29);
	4863	try expect(v[9] == 30);
	4864	try expect(v[10] == 31);
	4865	try expect(v[11] == 32);
	4866	c_vector_12_u8(.{ 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44 }, 12);
	4867	c_test_vector_12_u8();
	4868	}
	4869
	4870	export fn zig_ret_vector_16_u8() @Vector(16, u8) {
	4871	return .{ 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60 };
	4872	}
	4873	export fn zig_vector_16_u8(v: @Vector(16, u8), i: usize) void {
	4874	expect(v[0] == 61) catch @panic("test failure");
	4875	expect(v[1] == 62) catch @panic("test failure");
	4876	expect(v[2] == 63) catch @panic("test failure");
	4877	expect(v[3] == 64) catch @panic("test failure");
	4878	expect(v[4] == 65) catch @panic("test failure");
	4879	expect(v[5] == 66) catch @panic("test failure");
	4880	expect(v[6] == 67) catch @panic("test failure");
	4881	expect(v[7] == 68) catch @panic("test failure");
	4882	expect(v[8] == 69) catch @panic("test failure");
	4883	expect(v[9] == 70) catch @panic("test failure");
	4884	expect(v[10] == 71) catch @panic("test failure");
	4885	expect(v[11] == 72) catch @panic("test failure");
	4886	expect(v[12] == 73) catch @panic("test failure");
	4887	expect(v[13] == 74) catch @panic("test failure");
	4888	expect(v[14] == 75) catch @panic("test failure");
	4889	expect(v[15] == 76) catch @panic("test failure");
	4890	expect(i == 16) catch @panic("test failure");
	4891	}
	4892
	4893	extern fn c_ret_vector_16_u8() @Vector(16, u8);
	4894	extern fn c_vector_16_u8(@Vector(16, u8), usize) void;
	4895	extern fn c_test_vector_16_u8() void;
	4896
	4897	test "@Vector(16, u8)" {
	4898	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	4899
	4900	const v = c_ret_vector_16_u8();
	4901	try expect(v[0] == 77);
	4902	try expect(v[1] == 78);
	4903	try expect(v[2] == 79);
	4904	try expect(v[3] == 80);
	4905	try expect(v[4] == 81);
	4906	try expect(v[5] == 82);
	4907	try expect(v[6] == 83);
	4908	try expect(v[7] == 84);
	4909	try expect(v[8] == 85);
	4910	try expect(v[9] == 86);
	4911	try expect(v[10] == 87);
	4912	try expect(v[11] == 88);
	4913	try expect(v[12] == 89);
	4914	try expect(v[13] == 90);
	4915	try expect(v[14] == 91);
	4916	try expect(v[15] == 92);
	4917	c_vector_16_u8(.{ 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8 }, 16);
	4918	c_test_vector_16_u8();
	4919	}
	4920
	4921	export fn zig_ret_vector_24_u8() @Vector(24, u8) {
	4922	return .{
	4923	9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
	4924	25, 26, 27, 28, 29, 30, 31, 32,
	4925	};
	4926	}
	4927	export fn zig_vector_24_u8(v: @Vector(24, u8), i: usize) void {
	4928	expect(v[0] == 33) catch @panic("test failure");
	4929	expect(v[1] == 34) catch @panic("test failure");
	4930	expect(v[2] == 35) catch @panic("test failure");
	4931	expect(v[3] == 36) catch @panic("test failure");
	4932	expect(v[4] == 37) catch @panic("test failure");
	4933	expect(v[5] == 38) catch @panic("test failure");
	4934	expect(v[6] == 39) catch @panic("test failure");
	4935	expect(v[7] == 40) catch @panic("test failure");
	4936	expect(v[8] == 41) catch @panic("test failure");
	4937	expect(v[9] == 42) catch @panic("test failure");
	4938	expect(v[10] == 43) catch @panic("test failure");
	4939	expect(v[11] == 44) catch @panic("test failure");
	4940	expect(v[12] == 45) catch @panic("test failure");
	4941	expect(v[13] == 46) catch @panic("test failure");
	4942	expect(v[14] == 47) catch @panic("test failure");
	4943	expect(v[15] == 48) catch @panic("test failure");
	4944	expect(v[16] == 49) catch @panic("test failure");
	4945	expect(v[17] == 50) catch @panic("test failure");
	4946	expect(v[18] == 51) catch @panic("test failure");
	4947	expect(v[19] == 52) catch @panic("test failure");
	4948	expect(v[20] == 53) catch @panic("test failure");
	4949	expect(v[21] == 54) catch @panic("test failure");
	4950	expect(v[22] == 55) catch @panic("test failure");
	4951	expect(v[23] == 56) catch @panic("test failure");
	4952	expect(i == 24) catch @panic("test failure");
	4953	}
	4954
	4955	extern fn c_ret_vector_24_u8() @Vector(24, u8);
	4956	extern fn c_vector_24_u8(@Vector(24, u8), usize) void;
	4957	extern fn c_test_vector_24_u8() void;
	4958
	4959	test "@Vector(24, u8)" {
	4960	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	4961	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	4962	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	4963	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	4964	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	4965
	4966	const v = c_ret_vector_24_u8();
	4967	try expect(v[0] == 57);
	4968	try expect(v[1] == 58);
	4969	try expect(v[2] == 59);
	4970	try expect(v[3] == 60);
	4971	try expect(v[4] == 61);
	4972	try expect(v[5] == 62);
	4973	try expect(v[6] == 63);
	4974	try expect(v[7] == 64);
	4975	try expect(v[8] == 65);
	4976	try expect(v[9] == 66);
	4977	try expect(v[10] == 67);
	4978	try expect(v[11] == 68);
	4979	try expect(v[12] == 69);
	4980	try expect(v[13] == 70);
	4981	try expect(v[14] == 71);
	4982	try expect(v[15] == 72);
	4983	try expect(v[16] == 73);
	4984	try expect(v[17] == 74);
	4985	try expect(v[18] == 75);
	4986	try expect(v[19] == 76);
	4987	try expect(v[20] == 77);
	4988	try expect(v[21] == 78);
	4989	try expect(v[22] == 79);
	4990	try expect(v[23] == 80);
	4991	c_vector_24_u8(.{
	4992	81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
	4993	97, 98, 99, 0, 1, 2, 3, 4,
	4994	}, 24);
	4995	c_test_vector_24_u8();
	4996	}
	4997
	4998	export fn zig_ret_vector_32_u8() @Vector(32, u8) {
	4999	return .{
	5000	5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
	5001	21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
	5002	};
	5003	}
	5004	export fn zig_vector_32_u8(v: @Vector(32, u8), i: usize) void {
	5005	expect(v[0] == 37) catch @panic("test failure");
	5006	expect(v[1] == 38) catch @panic("test failure");
	5007	expect(v[2] == 39) catch @panic("test failure");
	5008	expect(v[3] == 40) catch @panic("test failure");
	5009	expect(v[4] == 41) catch @panic("test failure");
	5010	expect(v[5] == 42) catch @panic("test failure");
	5011	expect(v[6] == 43) catch @panic("test failure");
	5012	expect(v[7] == 44) catch @panic("test failure");
	5013	expect(v[8] == 45) catch @panic("test failure");
	5014	expect(v[9] == 46) catch @panic("test failure");
	5015	expect(v[10] == 47) catch @panic("test failure");
	5016	expect(v[11] == 48) catch @panic("test failure");
	5017	expect(v[12] == 49) catch @panic("test failure");
	5018	expect(v[13] == 50) catch @panic("test failure");
	5019	expect(v[14] == 51) catch @panic("test failure");
	5020	expect(v[15] == 52) catch @panic("test failure");
	5021	expect(v[16] == 53) catch @panic("test failure");
	5022	expect(v[17] == 54) catch @panic("test failure");
	5023	expect(v[18] == 55) catch @panic("test failure");
	5024	expect(v[19] == 56) catch @panic("test failure");
	5025	expect(v[20] == 57) catch @panic("test failure");
	5026	expect(v[21] == 58) catch @panic("test failure");
	5027	expect(v[22] == 59) catch @panic("test failure");
	5028	expect(v[23] == 60) catch @panic("test failure");
	5029	expect(v[24] == 61) catch @panic("test failure");
	5030	expect(v[25] == 62) catch @panic("test failure");
	5031	expect(v[26] == 63) catch @panic("test failure");
	5032	expect(v[27] == 64) catch @panic("test failure");
	5033	expect(v[28] == 65) catch @panic("test failure");
	5034	expect(v[29] == 66) catch @panic("test failure");
	5035	expect(v[30] == 67) catch @panic("test failure");
	5036	expect(v[31] == 68) catch @panic("test failure");
	5037	expect(i == 32) catch @panic("test failure");
	5038	}
	5039
	5040	extern fn c_ret_vector_32_u8() @Vector(32, u8);
	5041	extern fn c_vector_32_u8(@Vector(32, u8), usize) void;
	5042	extern fn c_test_vector_32_u8() void;
	5043
	5044	test "@Vector(32, u8)" {
	5045	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	5046	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	5047	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	5048	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	5049
	5050	const v = c_ret_vector_32_u8();
	5051	try expect(v[0] == 69);
	5052	try expect(v[1] == 70);
	5053	try expect(v[2] == 71);
	5054	try expect(v[3] == 72);
	5055	try expect(v[4] == 73);
	5056	try expect(v[5] == 74);
	5057	try expect(v[6] == 75);
	5058	try expect(v[7] == 76);
	5059	try expect(v[8] == 77);
	5060	try expect(v[9] == 78);
	5061	try expect(v[10] == 79);
	5062	try expect(v[11] == 80);
	5063	try expect(v[12] == 81);
	5064	try expect(v[13] == 82);
	5065	try expect(v[14] == 83);
	5066	try expect(v[15] == 84);
	5067	try expect(v[16] == 85);
	5068	try expect(v[17] == 86);
	5069	try expect(v[18] == 87);
	5070	try expect(v[19] == 88);
	5071	try expect(v[20] == 89);
	5072	try expect(v[21] == 90);
	5073	try expect(v[22] == 91);
	5074	try expect(v[23] == 92);
	5075	try expect(v[24] == 93);
	5076	try expect(v[25] == 94);
	5077	try expect(v[26] == 95);
	5078	try expect(v[27] == 96);
	5079	try expect(v[28] == 97);
	5080	try expect(v[29] == 98);
	5081	try expect(v[30] == 99);
	5082	try expect(v[31] == 0);
	5083	c_vector_32_u8(.{
	5084	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
	5085	17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
	5086	}, 32);
	5087	c_test_vector_32_u8();
	5088	}
	5089
	5090	export fn zig_ret_vector_48_u8() @Vector(48, u8) {
	5091	return .{
	5092	33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
	5093	49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
	5094	65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
	5095	};
	5096	}
	5097	export fn zig_vector_48_u8(v: @Vector(48, u8), i: usize) void {
	5098	expect(v[0] == 81) catch @panic("test failure");
	5099	expect(v[1] == 82) catch @panic("test failure");
	5100	expect(v[2] == 83) catch @panic("test failure");
	5101	expect(v[3] == 84) catch @panic("test failure");
	5102	expect(v[4] == 85) catch @panic("test failure");
	5103	expect(v[5] == 86) catch @panic("test failure");
	5104	expect(v[6] == 87) catch @panic("test failure");
	5105	expect(v[7] == 88) catch @panic("test failure");
	5106	expect(v[8] == 89) catch @panic("test failure");
	5107	expect(v[9] == 90) catch @panic("test failure");
	5108	expect(v[10] == 91) catch @panic("test failure");
	5109	expect(v[11] == 92) catch @panic("test failure");
	5110	expect(v[12] == 93) catch @panic("test failure");
	5111	expect(v[13] == 94) catch @panic("test failure");
	5112	expect(v[14] == 95) catch @panic("test failure");
	5113	expect(v[15] == 96) catch @panic("test failure");
	5114	expect(v[16] == 97) catch @panic("test failure");
	5115	expect(v[17] == 98) catch @panic("test failure");
	5116	expect(v[18] == 99) catch @panic("test failure");
	5117	expect(v[19] == 0) catch @panic("test failure");
	5118	expect(v[20] == 1) catch @panic("test failure");
	5119	expect(v[21] == 2) catch @panic("test failure");
	5120	expect(v[22] == 3) catch @panic("test failure");
	5121	expect(v[23] == 4) catch @panic("test failure");
	5122	expect(v[24] == 5) catch @panic("test failure");
	5123	expect(v[25] == 6) catch @panic("test failure");
	5124	expect(v[26] == 7) catch @panic("test failure");
	5125	expect(v[27] == 8) catch @panic("test failure");
	5126	expect(v[28] == 9) catch @panic("test failure");
	5127	expect(v[29] == 10) catch @panic("test failure");
	5128	expect(v[30] == 11) catch @panic("test failure");
	5129	expect(v[31] == 12) catch @panic("test failure");
	5130	expect(v[32] == 13) catch @panic("test failure");
	5131	expect(v[33] == 14) catch @panic("test failure");
	5132	expect(v[34] == 15) catch @panic("test failure");
	5133	expect(v[35] == 16) catch @panic("test failure");
	5134	expect(v[36] == 17) catch @panic("test failure");
	5135	expect(v[37] == 18) catch @panic("test failure");
	5136	expect(v[38] == 19) catch @panic("test failure");
	5137	expect(v[39] == 20) catch @panic("test failure");
	5138	expect(v[40] == 21) catch @panic("test failure");
	5139	expect(v[41] == 22) catch @panic("test failure");
	5140	expect(v[42] == 23) catch @panic("test failure");
	5141	expect(v[43] == 24) catch @panic("test failure");
	5142	expect(v[44] == 25) catch @panic("test failure");
	5143	expect(v[45] == 26) catch @panic("test failure");
	5144	expect(v[46] == 27) catch @panic("test failure");
	5145	expect(v[47] == 28) catch @panic("test failure");
	5146	expect(i == 48) catch @panic("test failure");
	5147	}
	5148
	5149	extern fn c_ret_vector_48_u8() @Vector(48, u8);
	5150	extern fn c_vector_48_u8(@Vector(48, u8), usize) void;
	5151	extern fn c_test_vector_48_u8() void;
	5152
	5153	test "@Vector(48, u8)" {
	5154	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	5155	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	5156	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	5157	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	5158	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	5159
	5160	const v = c_ret_vector_48_u8();
	5161	try expect(v[0] == 29);
	5162	try expect(v[1] == 30);
	5163	try expect(v[2] == 31);
	5164	try expect(v[3] == 32);
	5165	try expect(v[4] == 33);
	5166	try expect(v[5] == 34);
	5167	try expect(v[6] == 35);
	5168	try expect(v[7] == 36);
	5169	try expect(v[8] == 37);
	5170	try expect(v[9] == 38);
	5171	try expect(v[10] == 39);
	5172	try expect(v[11] == 40);
	5173	try expect(v[12] == 41);
	5174	try expect(v[13] == 42);
	5175	try expect(v[14] == 43);
	5176	try expect(v[15] == 44);
	5177	try expect(v[16] == 45);
	5178	try expect(v[17] == 46);
	5179	try expect(v[18] == 47);
	5180	try expect(v[19] == 48);
	5181	try expect(v[20] == 49);
	5182	try expect(v[21] == 50);
	5183	try expect(v[22] == 51);
	5184	try expect(v[23] == 52);
	5185	try expect(v[24] == 53);
	5186	try expect(v[25] == 54);
	5187	try expect(v[26] == 55);
	5188	try expect(v[27] == 56);
	5189	try expect(v[28] == 57);
	5190	try expect(v[29] == 58);
	5191	try expect(v[30] == 59);
	5192	try expect(v[31] == 60);
	5193	try expect(v[32] == 61);
	5194	try expect(v[33] == 62);
	5195	try expect(v[34] == 63);
	5196	try expect(v[35] == 64);
	5197	try expect(v[36] == 65);
	5198	try expect(v[37] == 66);
	5199	try expect(v[38] == 67);
	5200	try expect(v[39] == 68);
	5201	try expect(v[40] == 69);
	5202	try expect(v[41] == 70);
	5203	try expect(v[42] == 71);
	5204	try expect(v[43] == 72);
	5205	try expect(v[44] == 73);
	5206	try expect(v[45] == 74);
	5207	try expect(v[46] == 75);
	5208	try expect(v[47] == 76);
	5209	c_vector_48_u8(.{
	5210	77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92,
	5211	93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8,
	5212	9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
	5213	}, 48);
	5214	c_test_vector_48_u8();
	5215	}
	5216
	5217	export fn zig_ret_vector_64_u8() @Vector(64, u8) {
	5218	return .{
	5219	25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
	5220	41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56,
	5221	57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
	5222	73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88,
	5223	};
	5224	}
	5225	export fn zig_vector_64_u8(v: @Vector(64, u8), i: usize) void {
	5226	expect(v[0] == 89) catch @panic("test failure");
	5227	expect(v[1] == 90) catch @panic("test failure");
	5228	expect(v[2] == 91) catch @panic("test failure");
	5229	expect(v[3] == 92) catch @panic("test failure");
	5230	expect(v[4] == 93) catch @panic("test failure");
	5231	expect(v[5] == 94) catch @panic("test failure");
	5232	expect(v[6] == 95) catch @panic("test failure");
	5233	expect(v[7] == 96) catch @panic("test failure");
	5234	expect(v[8] == 97) catch @panic("test failure");
	5235	expect(v[9] == 98) catch @panic("test failure");
	5236	expect(v[10] == 99) catch @panic("test failure");
	5237	expect(v[11] == 0) catch @panic("test failure");
	5238	expect(v[12] == 1) catch @panic("test failure");
	5239	expect(v[13] == 2) catch @panic("test failure");
	5240	expect(v[14] == 3) catch @panic("test failure");
	5241	expect(v[15] == 4) catch @panic("test failure");
	5242	expect(v[16] == 5) catch @panic("test failure");
	5243	expect(v[17] == 6) catch @panic("test failure");
	5244	expect(v[18] == 7) catch @panic("test failure");
	5245	expect(v[19] == 8) catch @panic("test failure");
	5246	expect(v[20] == 9) catch @panic("test failure");
	5247	expect(v[21] == 10) catch @panic("test failure");
	5248	expect(v[22] == 11) catch @panic("test failure");
	5249	expect(v[23] == 12) catch @panic("test failure");
	5250	expect(v[24] == 13) catch @panic("test failure");
	5251	expect(v[25] == 14) catch @panic("test failure");
	5252	expect(v[26] == 15) catch @panic("test failure");
	5253	expect(v[27] == 16) catch @panic("test failure");
	5254	expect(v[28] == 17) catch @panic("test failure");
	5255	expect(v[29] == 18) catch @panic("test failure");
	5256	expect(v[30] == 19) catch @panic("test failure");
	5257	expect(v[31] == 20) catch @panic("test failure");
	5258	expect(v[32] == 21) catch @panic("test failure");
	5259	expect(v[33] == 22) catch @panic("test failure");
	5260	expect(v[34] == 23) catch @panic("test failure");
	5261	expect(v[35] == 24) catch @panic("test failure");
	5262	expect(v[36] == 25) catch @panic("test failure");
	5263	expect(v[37] == 26) catch @panic("test failure");
	5264	expect(v[38] == 27) catch @panic("test failure");
	5265	expect(v[39] == 28) catch @panic("test failure");
	5266	expect(v[40] == 29) catch @panic("test failure");
	5267	expect(v[41] == 30) catch @panic("test failure");
	5268	expect(v[42] == 31) catch @panic("test failure");
	5269	expect(v[43] == 32) catch @panic("test failure");
	5270	expect(v[44] == 33) catch @panic("test failure");
	5271	expect(v[45] == 34) catch @panic("test failure");
	5272	expect(v[46] == 35) catch @panic("test failure");
	5273	expect(v[47] == 36) catch @panic("test failure");
	5274	expect(v[48] == 37) catch @panic("test failure");
	5275	expect(v[49] == 38) catch @panic("test failure");
	5276	expect(v[50] == 39) catch @panic("test failure");
	5277	expect(v[51] == 40) catch @panic("test failure");
	5278	expect(v[52] == 41) catch @panic("test failure");
	5279	expect(v[53] == 42) catch @panic("test failure");
	5280	expect(v[54] == 43) catch @panic("test failure");
	5281	expect(v[55] == 44) catch @panic("test failure");
	5282	expect(v[56] == 45) catch @panic("test failure");
	5283	expect(v[57] == 46) catch @panic("test failure");
	5284	expect(v[58] == 47) catch @panic("test failure");
	5285	expect(v[59] == 48) catch @panic("test failure");
	5286	expect(v[60] == 49) catch @panic("test failure");
	5287	expect(v[61] == 50) catch @panic("test failure");
	5288	expect(v[62] == 51) catch @panic("test failure");
	5289	expect(v[63] == 52) catch @panic("test failure");
	5290	expect(i == 64) catch @panic("test failure");
	5291	}
	5292
	5293	extern fn c_ret_vector_64_u8() @Vector(64, u8);
	5294	extern fn c_vector_64_u8(@Vector(64, u8), usize) void;
	5295	extern fn c_test_vector_64_u8() void;
	5296
	5297	test "@Vector(64, u8)" {
	5298	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	5299	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	5300	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	5301	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	5302
	5303	const v = c_ret_vector_64_u8();
	5304	try expect(v[0] == 53);
	5305	try expect(v[1] == 54);
	5306	try expect(v[2] == 55);
	5307	try expect(v[3] == 56);
	5308	try expect(v[4] == 57);
	5309	try expect(v[5] == 58);
	5310	try expect(v[6] == 59);
	5311	try expect(v[7] == 60);
	5312	try expect(v[8] == 61);
	5313	try expect(v[9] == 62);
	5314	try expect(v[10] == 63);
	5315	try expect(v[11] == 64);
	5316	try expect(v[12] == 65);
	5317	try expect(v[13] == 66);
	5318	try expect(v[14] == 67);
	5319	try expect(v[15] == 68);
	5320	try expect(v[16] == 69);
	5321	try expect(v[17] == 70);
	5322	try expect(v[18] == 71);
	5323	try expect(v[19] == 72);
	5324	try expect(v[20] == 73);
	5325	try expect(v[21] == 74);
	5326	try expect(v[22] == 75);
	5327	try expect(v[23] == 76);
	5328	try expect(v[24] == 77);
	5329	try expect(v[25] == 78);
	5330	try expect(v[26] == 79);
	5331	try expect(v[27] == 80);
	5332	try expect(v[28] == 81);
	5333	try expect(v[29] == 82);
	5334	try expect(v[30] == 83);
	5335	try expect(v[31] == 84);
	5336	try expect(v[32] == 85);
	5337	try expect(v[33] == 86);
	5338	try expect(v[34] == 87);
	5339	try expect(v[35] == 88);
	5340	try expect(v[36] == 89);
	5341	try expect(v[37] == 90);
	5342	try expect(v[38] == 91);
	5343	try expect(v[39] == 92);
	5344	try expect(v[40] == 93);
	5345	try expect(v[41] == 94);
	5346	try expect(v[42] == 95);
	5347	try expect(v[43] == 96);
	5348	try expect(v[44] == 97);
	5349	try expect(v[45] == 98);
	5350	try expect(v[46] == 99);
	5351	try expect(v[47] == 0);
	5352	try expect(v[48] == 1);
	5353	try expect(v[49] == 2);
	5354	try expect(v[50] == 3);
	5355	try expect(v[51] == 4);
	5356	try expect(v[52] == 5);
	5357	try expect(v[53] == 6);
	5358	try expect(v[54] == 7);
	5359	try expect(v[55] == 8);
	5360	try expect(v[56] == 9);
	5361	try expect(v[57] == 10);
	5362	try expect(v[58] == 11);
	5363	try expect(v[59] == 12);
	5364	try expect(v[60] == 13);
	5365	try expect(v[61] == 14);
	5366	try expect(v[62] == 15);
	5367	try expect(v[63] == 16);
	5368	c_vector_64_u8(.{
	5369	17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
	5370	33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
	5371	49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
	5372	65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80,
	5373	}, 64);
	5374	c_test_vector_64_u8();
	5375	}
	5376
	5377	export fn zig_ret_vector_96_u8() @Vector(96, u8) {
	5378	return .{
	5379	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	5380	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	5381	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	5382	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	5383	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	5384	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	5385	};
	5386	}
	5387	export fn zig_vector_96_u8(v: @Vector(96, u8), i: usize) void {
	5388	expect(v[0] == 86) catch @panic("test failure");
	5389	expect(v[1] == 87) catch @panic("test failure");
	5390	expect(v[2] == 88) catch @panic("test failure");
	5391	expect(v[3] == 89) catch @panic("test failure");
	5392	expect(v[4] == 90) catch @panic("test failure");
	5393	expect(v[5] == 91) catch @panic("test failure");
	5394	expect(v[6] == 92) catch @panic("test failure");
	5395	expect(v[7] == 93) catch @panic("test failure");
	5396	expect(v[8] == 94) catch @panic("test failure");
	5397	expect(v[9] == 95) catch @panic("test failure");
	5398	expect(v[10] == 96) catch @panic("test failure");
	5399	expect(v[11] == 97) catch @panic("test failure");
	5400	expect(v[12] == 98) catch @panic("test failure");
	5401	expect(v[13] == 99) catch @panic("test failure");
	5402	expect(v[14] == 0) catch @panic("test failure");
	5403	expect(v[15] == 1) catch @panic("test failure");
	5404	expect(v[16] == 2) catch @panic("test failure");
	5405	expect(v[17] == 3) catch @panic("test failure");
	5406	expect(v[18] == 4) catch @panic("test failure");
	5407	expect(v[19] == 5) catch @panic("test failure");
	5408	expect(v[20] == 6) catch @panic("test failure");
	5409	expect(v[21] == 7) catch @panic("test failure");
	5410	expect(v[22] == 8) catch @panic("test failure");
	5411	expect(v[23] == 9) catch @panic("test failure");
	5412	expect(v[24] == 10) catch @panic("test failure");
	5413	expect(v[25] == 11) catch @panic("test failure");
	5414	expect(v[26] == 12) catch @panic("test failure");
	5415	expect(v[27] == 13) catch @panic("test failure");
	5416	expect(v[28] == 14) catch @panic("test failure");
	5417	expect(v[29] == 15) catch @panic("test failure");
	5418	expect(v[30] == 16) catch @panic("test failure");
	5419	expect(v[31] == 17) catch @panic("test failure");
	5420	expect(v[32] == 18) catch @panic("test failure");
	5421	expect(v[33] == 19) catch @panic("test failure");
	5422	expect(v[34] == 20) catch @panic("test failure");
	5423	expect(v[35] == 21) catch @panic("test failure");
	5424	expect(v[36] == 22) catch @panic("test failure");
	5425	expect(v[37] == 23) catch @panic("test failure");
	5426	expect(v[38] == 24) catch @panic("test failure");
	5427	expect(v[39] == 25) catch @panic("test failure");
	5428	expect(v[40] == 26) catch @panic("test failure");
	5429	expect(v[41] == 27) catch @panic("test failure");
	5430	expect(v[42] == 28) catch @panic("test failure");
	5431	expect(v[43] == 29) catch @panic("test failure");
	5432	expect(v[44] == 30) catch @panic("test failure");
	5433	expect(v[45] == 31) catch @panic("test failure");
	5434	expect(v[46] == 32) catch @panic("test failure");
	5435	expect(v[47] == 33) catch @panic("test failure");
	5436	expect(v[48] == 34) catch @panic("test failure");
	5437	expect(v[49] == 35) catch @panic("test failure");
	5438	expect(v[50] == 36) catch @panic("test failure");
	5439	expect(v[51] == 37) catch @panic("test failure");
	5440	expect(v[52] == 38) catch @panic("test failure");
	5441	expect(v[53] == 39) catch @panic("test failure");
	5442	expect(v[54] == 40) catch @panic("test failure");
	5443	expect(v[55] == 41) catch @panic("test failure");
	5444	expect(v[56] == 42) catch @panic("test failure");
	5445	expect(v[57] == 43) catch @panic("test failure");
	5446	expect(v[58] == 44) catch @panic("test failure");
	5447	expect(v[59] == 45) catch @panic("test failure");
	5448	expect(v[60] == 46) catch @panic("test failure");
	5449	expect(v[61] == 47) catch @panic("test failure");
	5450	expect(v[62] == 48) catch @panic("test failure");
	5451	expect(v[63] == 49) catch @panic("test failure");
	5452	expect(v[64] == 50) catch @panic("test failure");
	5453	expect(v[65] == 51) catch @panic("test failure");
	5454	expect(v[66] == 52) catch @panic("test failure");
	5455	expect(v[67] == 53) catch @panic("test failure");
	5456	expect(v[68] == 54) catch @panic("test failure");
	5457	expect(v[69] == 55) catch @panic("test failure");
	5458	expect(v[70] == 56) catch @panic("test failure");
	5459	expect(v[71] == 57) catch @panic("test failure");
	5460	expect(v[72] == 58) catch @panic("test failure");
	5461	expect(v[73] == 59) catch @panic("test failure");
	5462	expect(v[74] == 60) catch @panic("test failure");
	5463	expect(v[75] == 61) catch @panic("test failure");
	5464	expect(v[76] == 62) catch @panic("test failure");
	5465	expect(v[77] == 63) catch @panic("test failure");
	5466	expect(v[78] == 64) catch @panic("test failure");
	5467	expect(v[79] == 65) catch @panic("test failure");
	5468	expect(v[80] == 66) catch @panic("test failure");
	5469	expect(v[81] == 67) catch @panic("test failure");
	5470	expect(v[82] == 68) catch @panic("test failure");
	5471	expect(v[83] == 69) catch @panic("test failure");
	5472	expect(v[84] == 70) catch @panic("test failure");
	5473	expect(v[85] == 71) catch @panic("test failure");
	5474	expect(v[86] == 72) catch @panic("test failure");
	5475	expect(v[87] == 73) catch @panic("test failure");
	5476	expect(v[88] == 74) catch @panic("test failure");
	5477	expect(v[89] == 75) catch @panic("test failure");
	5478	expect(v[90] == 76) catch @panic("test failure");
	5479	expect(v[91] == 77) catch @panic("test failure");
	5480	expect(v[92] == 78) catch @panic("test failure");
	5481	expect(v[93] == 79) catch @panic("test failure");
	5482	expect(v[94] == 80) catch @panic("test failure");
	5483	expect(v[95] == 81) catch @panic("test failure");
	5484	expect(i == 96) catch @panic("test failure");
	5485	}
	5486
	5487	extern fn c_ret_vector_96_u8() @Vector(96, u8);
	5488	extern fn c_vector_96_u8(@Vector(96, u8), usize) void;
	5489	extern fn c_test_vector_96_u8() void;
	5490
	5491	test "@Vector(96, u8)" {
	5492	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	5493	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	5494	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	5495	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	5496	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	5497
	5498	const v = c_ret_vector_96_u8();
	5499	try expect(v[0] == 82);
	5500	try expect(v[1] == 83);
	5501	try expect(v[2] == 84);
	5502	try expect(v[3] == 85);
	5503	try expect(v[4] == 86);
	5504	try expect(v[5] == 87);
	5505	try expect(v[6] == 88);
	5506	try expect(v[7] == 89);
	5507	try expect(v[8] == 90);
	5508	try expect(v[9] == 91);
	5509	try expect(v[10] == 92);
	5510	try expect(v[11] == 93);
	5511	try expect(v[12] == 94);
	5512	try expect(v[13] == 95);
	5513	try expect(v[14] == 96);
	5514	try expect(v[15] == 97);
	5515	try expect(v[16] == 98);
	5516	try expect(v[17] == 99);
	5517	try expect(v[18] == 0);
	5518	try expect(v[19] == 1);
	5519	try expect(v[20] == 2);
	5520	try expect(v[21] == 3);
	5521	try expect(v[22] == 4);
	5522	try expect(v[23] == 5);
	5523	try expect(v[24] == 6);
	5524	try expect(v[25] == 7);
	5525	try expect(v[26] == 8);
	5526	try expect(v[27] == 9);
	5527	try expect(v[28] == 10);
	5528	try expect(v[29] == 11);
	5529	try expect(v[30] == 12);
	5530	try expect(v[31] == 13);
	5531	try expect(v[32] == 14);
	5532	try expect(v[33] == 15);
	5533	try expect(v[34] == 16);
	5534	try expect(v[35] == 17);
	5535	try expect(v[36] == 18);
	5536	try expect(v[37] == 19);
	5537	try expect(v[38] == 20);
	5538	try expect(v[39] == 21);
	5539	try expect(v[40] == 22);
	5540	try expect(v[41] == 23);
	5541	try expect(v[42] == 24);
	5542	try expect(v[43] == 25);
	5543	try expect(v[44] == 26);
	5544	try expect(v[45] == 27);
	5545	try expect(v[46] == 28);
	5546	try expect(v[47] == 29);
	5547	try expect(v[48] == 30);
	5548	try expect(v[49] == 31);
	5549	try expect(v[50] == 32);
	5550	try expect(v[51] == 33);
	5551	try expect(v[52] == 34);
	5552	try expect(v[53] == 35);
	5553	try expect(v[54] == 36);
	5554	try expect(v[55] == 37);
	5555	try expect(v[56] == 38);
	5556	try expect(v[57] == 39);
	5557	try expect(v[58] == 40);
	5558	try expect(v[59] == 41);
	5559	try expect(v[60] == 42);
	5560	try expect(v[61] == 43);
	5561	try expect(v[62] == 44);
	5562	try expect(v[63] == 45);
	5563	try expect(v[64] == 46);
	5564	try expect(v[65] == 47);
	5565	try expect(v[66] == 48);
	5566	try expect(v[67] == 49);
	5567	try expect(v[68] == 50);
	5568	try expect(v[69] == 51);
	5569	try expect(v[70] == 52);
	5570	try expect(v[71] == 53);
	5571	try expect(v[72] == 54);
	5572	try expect(v[73] == 55);
	5573	try expect(v[74] == 56);
	5574	try expect(v[75] == 57);
	5575	try expect(v[76] == 58);
	5576	try expect(v[77] == 59);
	5577	try expect(v[78] == 60);
	5578	try expect(v[79] == 61);
	5579	try expect(v[80] == 62);
	5580	try expect(v[81] == 63);
	5581	try expect(v[82] == 64);
	5582	try expect(v[83] == 65);
	5583	try expect(v[84] == 66);
	5584	try expect(v[85] == 67);
	5585	try expect(v[86] == 68);
	5586	try expect(v[87] == 69);
	5587	try expect(v[88] == 70);
	5588	try expect(v[89] == 71);
	5589	try expect(v[90] == 72);
	5590	try expect(v[91] == 73);
	5591	try expect(v[92] == 74);
	5592	try expect(v[93] == 75);
	5593	try expect(v[94] == 76);
	5594	try expect(v[95] == 77);
	5595	c_vector_96_u8(.{
	5596	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	5597	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	5598	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	5599	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	5600	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	5601	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	5602	}, 96);
	5603	c_test_vector_96_u8();
	5604	}
	5605
	5606	export fn zig_ret_vector_128_u8() @Vector(128, u8) {
	5607	return .{
	5608	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	5609	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	5610	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	5611	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	5612	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	5613	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	5614	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	5615	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	5616	};
	5617	}
	5618	export fn zig_vector_128_u8(v: @Vector(128, u8), i: usize) void {
	5619	expect(v[0] == 2) catch @panic("test failure");
	5620	expect(v[1] == 3) catch @panic("test failure");
	5621	expect(v[2] == 4) catch @panic("test failure");
	5622	expect(v[3] == 5) catch @panic("test failure");
	5623	expect(v[4] == 6) catch @panic("test failure");
	5624	expect(v[5] == 7) catch @panic("test failure");
	5625	expect(v[6] == 8) catch @panic("test failure");
	5626	expect(v[7] == 9) catch @panic("test failure");
	5627	expect(v[8] == 10) catch @panic("test failure");
	5628	expect(v[9] == 11) catch @panic("test failure");
	5629	expect(v[10] == 12) catch @panic("test failure");
	5630	expect(v[11] == 13) catch @panic("test failure");
	5631	expect(v[12] == 14) catch @panic("test failure");
	5632	expect(v[13] == 15) catch @panic("test failure");
	5633	expect(v[14] == 16) catch @panic("test failure");
	5634	expect(v[15] == 17) catch @panic("test failure");
	5635	expect(v[16] == 18) catch @panic("test failure");
	5636	expect(v[17] == 19) catch @panic("test failure");
	5637	expect(v[18] == 20) catch @panic("test failure");
	5638	expect(v[19] == 21) catch @panic("test failure");
	5639	expect(v[20] == 22) catch @panic("test failure");
	5640	expect(v[21] == 23) catch @panic("test failure");
	5641	expect(v[22] == 24) catch @panic("test failure");
	5642	expect(v[23] == 25) catch @panic("test failure");
	5643	expect(v[24] == 26) catch @panic("test failure");
	5644	expect(v[25] == 27) catch @panic("test failure");
	5645	expect(v[26] == 28) catch @panic("test failure");
	5646	expect(v[27] == 29) catch @panic("test failure");
	5647	expect(v[28] == 30) catch @panic("test failure");
	5648	expect(v[29] == 31) catch @panic("test failure");
	5649	expect(v[30] == 32) catch @panic("test failure");
	5650	expect(v[31] == 33) catch @panic("test failure");
	5651	expect(v[32] == 34) catch @panic("test failure");
	5652	expect(v[33] == 35) catch @panic("test failure");
	5653	expect(v[34] == 36) catch @panic("test failure");
	5654	expect(v[35] == 37) catch @panic("test failure");
	5655	expect(v[36] == 38) catch @panic("test failure");
	5656	expect(v[37] == 39) catch @panic("test failure");
	5657	expect(v[38] == 40) catch @panic("test failure");
	5658	expect(v[39] == 41) catch @panic("test failure");
	5659	expect(v[40] == 42) catch @panic("test failure");
	5660	expect(v[41] == 43) catch @panic("test failure");
	5661	expect(v[42] == 44) catch @panic("test failure");
	5662	expect(v[43] == 45) catch @panic("test failure");
	5663	expect(v[44] == 46) catch @panic("test failure");
	5664	expect(v[45] == 47) catch @panic("test failure");
	5665	expect(v[46] == 48) catch @panic("test failure");
	5666	expect(v[47] == 49) catch @panic("test failure");
	5667	expect(v[48] == 50) catch @panic("test failure");
	5668	expect(v[49] == 51) catch @panic("test failure");
	5669	expect(v[50] == 52) catch @panic("test failure");
	5670	expect(v[51] == 53) catch @panic("test failure");
	5671	expect(v[52] == 54) catch @panic("test failure");
	5672	expect(v[53] == 55) catch @panic("test failure");
	5673	expect(v[54] == 56) catch @panic("test failure");
	5674	expect(v[55] == 57) catch @panic("test failure");
	5675	expect(v[56] == 58) catch @panic("test failure");
	5676	expect(v[57] == 59) catch @panic("test failure");
	5677	expect(v[58] == 60) catch @panic("test failure");
	5678	expect(v[59] == 61) catch @panic("test failure");
	5679	expect(v[60] == 62) catch @panic("test failure");
	5680	expect(v[61] == 63) catch @panic("test failure");
	5681	expect(v[62] == 64) catch @panic("test failure");
	5682	expect(v[63] == 65) catch @panic("test failure");
	5683	expect(v[64] == 66) catch @panic("test failure");
	5684	expect(v[65] == 67) catch @panic("test failure");
	5685	expect(v[66] == 68) catch @panic("test failure");
	5686	expect(v[67] == 69) catch @panic("test failure");
	5687	expect(v[68] == 70) catch @panic("test failure");
	5688	expect(v[69] == 71) catch @panic("test failure");
	5689	expect(v[70] == 72) catch @panic("test failure");
	5690	expect(v[71] == 73) catch @panic("test failure");
	5691	expect(v[72] == 74) catch @panic("test failure");
	5692	expect(v[73] == 75) catch @panic("test failure");
	5693	expect(v[74] == 76) catch @panic("test failure");
	5694	expect(v[75] == 77) catch @panic("test failure");
	5695	expect(v[76] == 78) catch @panic("test failure");
	5696	expect(v[77] == 79) catch @panic("test failure");
	5697	expect(v[78] == 80) catch @panic("test failure");
	5698	expect(v[79] == 81) catch @panic("test failure");
	5699	expect(v[80] == 82) catch @panic("test failure");
	5700	expect(v[81] == 83) catch @panic("test failure");
	5701	expect(v[82] == 84) catch @panic("test failure");
	5702	expect(v[83] == 85) catch @panic("test failure");
	5703	expect(v[84] == 86) catch @panic("test failure");
	5704	expect(v[85] == 87) catch @panic("test failure");
	5705	expect(v[86] == 88) catch @panic("test failure");
	5706	expect(v[87] == 89) catch @panic("test failure");
	5707	expect(v[88] == 90) catch @panic("test failure");
	5708	expect(v[89] == 91) catch @panic("test failure");
	5709	expect(v[90] == 92) catch @panic("test failure");
	5710	expect(v[91] == 93) catch @panic("test failure");
	5711	expect(v[92] == 94) catch @panic("test failure");
	5712	expect(v[93] == 95) catch @panic("test failure");
	5713	expect(v[94] == 96) catch @panic("test failure");
	5714	expect(v[95] == 97) catch @panic("test failure");
	5715	expect(v[96] == 98) catch @panic("test failure");
	5716	expect(v[97] == 99) catch @panic("test failure");
	5717	expect(v[98] == 0) catch @panic("test failure");
	5718	expect(v[99] == 1) catch @panic("test failure");
	5719	expect(v[100] == 2) catch @panic("test failure");
	5720	expect(v[101] == 3) catch @panic("test failure");
	5721	expect(v[102] == 4) catch @panic("test failure");
	5722	expect(v[103] == 5) catch @panic("test failure");
	5723	expect(v[104] == 6) catch @panic("test failure");
	5724	expect(v[105] == 7) catch @panic("test failure");
	5725	expect(v[106] == 8) catch @panic("test failure");
	5726	expect(v[107] == 9) catch @panic("test failure");
	5727	expect(v[108] == 10) catch @panic("test failure");
	5728	expect(v[109] == 11) catch @panic("test failure");
	5729	expect(v[110] == 12) catch @panic("test failure");
	5730	expect(v[111] == 13) catch @panic("test failure");
	5731	expect(v[112] == 14) catch @panic("test failure");
	5732	expect(v[113] == 15) catch @panic("test failure");
	5733	expect(v[114] == 16) catch @panic("test failure");
	5734	expect(v[115] == 17) catch @panic("test failure");
	5735	expect(v[116] == 18) catch @panic("test failure");
	5736	expect(v[117] == 19) catch @panic("test failure");
	5737	expect(v[118] == 20) catch @panic("test failure");
	5738	expect(v[119] == 21) catch @panic("test failure");
	5739	expect(v[120] == 22) catch @panic("test failure");
	5740	expect(v[121] == 23) catch @panic("test failure");
	5741	expect(v[122] == 24) catch @panic("test failure");
	5742	expect(v[123] == 25) catch @panic("test failure");
	5743	expect(v[124] == 26) catch @panic("test failure");
	5744	expect(v[125] == 27) catch @panic("test failure");
	5745	expect(v[126] == 28) catch @panic("test failure");
	5746	expect(v[127] == 29) catch @panic("test failure");
	5747	expect(i == 128) catch @panic("test failure");
	5748	}
	5749
	5750	extern fn c_ret_vector_128_u8() @Vector(128, u8);
	5751	extern fn c_vector_128_u8(@Vector(128, u8), usize) void;
	5752	extern fn c_test_vector_128_u8() void;
	5753
	5754	test "@Vector(128, u8)" {
	5755	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	5756	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	5757	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	5758	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	5759	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	5760
	5761	const v = c_ret_vector_128_u8();
	5762	try expect(v[0] == 30);
	5763	try expect(v[1] == 31);
	5764	try expect(v[2] == 32);
	5765	try expect(v[3] == 33);
	5766	try expect(v[4] == 34);
	5767	try expect(v[5] == 35);
	5768	try expect(v[6] == 36);
	5769	try expect(v[7] == 37);
	5770	try expect(v[8] == 38);
	5771	try expect(v[9] == 39);
	5772	try expect(v[10] == 40);
	5773	try expect(v[11] == 41);
	5774	try expect(v[12] == 42);
	5775	try expect(v[13] == 43);
	5776	try expect(v[14] == 44);
	5777	try expect(v[15] == 45);
	5778	try expect(v[16] == 46);
	5779	try expect(v[17] == 47);
	5780	try expect(v[18] == 48);
	5781	try expect(v[19] == 49);
	5782	try expect(v[20] == 50);
	5783	try expect(v[21] == 51);
	5784	try expect(v[22] == 52);
	5785	try expect(v[23] == 53);
	5786	try expect(v[24] == 54);
	5787	try expect(v[25] == 55);
	5788	try expect(v[26] == 56);
	5789	try expect(v[27] == 57);
	5790	try expect(v[28] == 58);
	5791	try expect(v[29] == 59);
	5792	try expect(v[30] == 60);
	5793	try expect(v[31] == 61);
	5794	try expect(v[32] == 62);
	5795	try expect(v[33] == 63);
	5796	try expect(v[34] == 64);
	5797	try expect(v[35] == 65);
	5798	try expect(v[36] == 66);
	5799	try expect(v[37] == 67);
	5800	try expect(v[38] == 68);
	5801	try expect(v[39] == 69);
	5802	try expect(v[40] == 70);
	5803	try expect(v[41] == 71);
	5804	try expect(v[42] == 72);
	5805	try expect(v[43] == 73);
	5806	try expect(v[44] == 74);
	5807	try expect(v[45] == 75);
	5808	try expect(v[46] == 76);
	5809	try expect(v[47] == 77);
	5810	try expect(v[48] == 78);
	5811	try expect(v[49] == 79);
	5812	try expect(v[50] == 80);
	5813	try expect(v[51] == 81);
	5814	try expect(v[52] == 82);
	5815	try expect(v[53] == 83);
	5816	try expect(v[54] == 84);
	5817	try expect(v[55] == 85);
	5818	try expect(v[56] == 86);
	5819	try expect(v[57] == 87);
	5820	try expect(v[58] == 88);
	5821	try expect(v[59] == 89);
	5822	try expect(v[60] == 90);
	5823	try expect(v[61] == 91);
	5824	try expect(v[62] == 92);
	5825	try expect(v[63] == 93);
	5826	try expect(v[64] == 94);
	5827	try expect(v[65] == 95);
	5828	try expect(v[66] == 96);
	5829	try expect(v[67] == 97);
	5830	try expect(v[68] == 98);
	5831	try expect(v[69] == 99);
	5832	try expect(v[70] == 0);
	5833	try expect(v[71] == 1);
	5834	try expect(v[72] == 2);
	5835	try expect(v[73] == 3);
	5836	try expect(v[74] == 4);
	5837	try expect(v[75] == 5);
	5838	try expect(v[76] == 6);
	5839	try expect(v[77] == 7);
	5840	try expect(v[78] == 8);
	5841	try expect(v[79] == 9);
	5842	try expect(v[80] == 10);
	5843	try expect(v[81] == 11);
	5844	try expect(v[82] == 12);
	5845	try expect(v[83] == 13);
	5846	try expect(v[84] == 14);
	5847	try expect(v[85] == 15);
	5848	try expect(v[86] == 16);
	5849	try expect(v[87] == 17);
	5850	try expect(v[88] == 18);
	5851	try expect(v[89] == 19);
	5852	try expect(v[90] == 20);
	5853	try expect(v[91] == 21);
	5854	try expect(v[92] == 22);
	5855	try expect(v[93] == 23);
	5856	try expect(v[94] == 24);
	5857	try expect(v[95] == 25);
	5858	try expect(v[96] == 26);
	5859	try expect(v[97] == 27);
	5860	try expect(v[98] == 28);
	5861	try expect(v[99] == 29);
	5862	try expect(v[100] == 30);
	5863	try expect(v[101] == 31);
	5864	try expect(v[102] == 32);
	5865	try expect(v[103] == 33);
	5866	try expect(v[104] == 34);
	5867	try expect(v[105] == 35);
	5868	try expect(v[106] == 36);
	5869	try expect(v[107] == 37);
	5870	try expect(v[108] == 38);
	5871	try expect(v[109] == 39);
	5872	try expect(v[110] == 40);
	5873	try expect(v[111] == 41);
	5874	try expect(v[112] == 42);
	5875	try expect(v[113] == 43);
	5876	try expect(v[114] == 44);
	5877	try expect(v[115] == 45);
	5878	try expect(v[116] == 46);
	5879	try expect(v[117] == 47);
	5880	try expect(v[118] == 48);
	5881	try expect(v[119] == 49);
	5882	try expect(v[120] == 50);
	5883	try expect(v[121] == 51);
	5884	try expect(v[122] == 52);
	5885	try expect(v[123] == 53);
	5886	try expect(v[124] == 54);
	5887	try expect(v[125] == 55);
	5888	try expect(v[126] == 56);
	5889	try expect(v[127] == 57);
	5890	c_vector_128_u8(.{
	5891	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	5892	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	5893	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	5894	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	5895	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	5896	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	5897	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	5898	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	5899	}, 128);
	5900	c_test_vector_128_u8();
	5901	}
	5902
	5903	export fn zig_ret_vector_192_u8() @Vector(192, u8) {
	5904	return .{
	5905	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	5906	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	5907	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	5908	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	5909	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	5910	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	5911	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	5912	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	5913	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	5914	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	5915	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	5916	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	5917	};
	5918	}
	5919	export fn zig_vector_192_u8(v: @Vector(192, u8), i: usize) void {
	5920	expect(v[0] == 78) catch @panic("test failure");
	5921	expect(v[1] == 79) catch @panic("test failure");
	5922	expect(v[2] == 80) catch @panic("test failure");
	5923	expect(v[3] == 81) catch @panic("test failure");
	5924	expect(v[4] == 82) catch @panic("test failure");
	5925	expect(v[5] == 83) catch @panic("test failure");
	5926	expect(v[6] == 84) catch @panic("test failure");
	5927	expect(v[7] == 85) catch @panic("test failure");
	5928	expect(v[8] == 86) catch @panic("test failure");
	5929	expect(v[9] == 87) catch @panic("test failure");
	5930	expect(v[10] == 88) catch @panic("test failure");
	5931	expect(v[11] == 89) catch @panic("test failure");
	5932	expect(v[12] == 90) catch @panic("test failure");
	5933	expect(v[13] == 91) catch @panic("test failure");
	5934	expect(v[14] == 92) catch @panic("test failure");
	5935	expect(v[15] == 93) catch @panic("test failure");
	5936	expect(v[16] == 94) catch @panic("test failure");
	5937	expect(v[17] == 95) catch @panic("test failure");
	5938	expect(v[18] == 96) catch @panic("test failure");
	5939	expect(v[19] == 97) catch @panic("test failure");
	5940	expect(v[20] == 98) catch @panic("test failure");
	5941	expect(v[21] == 99) catch @panic("test failure");
	5942	expect(v[22] == 0) catch @panic("test failure");
	5943	expect(v[23] == 1) catch @panic("test failure");
	5944	expect(v[24] == 2) catch @panic("test failure");
	5945	expect(v[25] == 3) catch @panic("test failure");
	5946	expect(v[26] == 4) catch @panic("test failure");
	5947	expect(v[27] == 5) catch @panic("test failure");
	5948	expect(v[28] == 6) catch @panic("test failure");
	5949	expect(v[29] == 7) catch @panic("test failure");
	5950	expect(v[30] == 8) catch @panic("test failure");
	5951	expect(v[31] == 9) catch @panic("test failure");
	5952	expect(v[32] == 10) catch @panic("test failure");
	5953	expect(v[33] == 11) catch @panic("test failure");
	5954	expect(v[34] == 12) catch @panic("test failure");
	5955	expect(v[35] == 13) catch @panic("test failure");
	5956	expect(v[36] == 14) catch @panic("test failure");
	5957	expect(v[37] == 15) catch @panic("test failure");
	5958	expect(v[38] == 16) catch @panic("test failure");
	5959	expect(v[39] == 17) catch @panic("test failure");
	5960	expect(v[40] == 18) catch @panic("test failure");
	5961	expect(v[41] == 19) catch @panic("test failure");
	5962	expect(v[42] == 20) catch @panic("test failure");
	5963	expect(v[43] == 21) catch @panic("test failure");
	5964	expect(v[44] == 22) catch @panic("test failure");
	5965	expect(v[45] == 23) catch @panic("test failure");
	5966	expect(v[46] == 24) catch @panic("test failure");
	5967	expect(v[47] == 25) catch @panic("test failure");
	5968	expect(v[48] == 26) catch @panic("test failure");
	5969	expect(v[49] == 27) catch @panic("test failure");
	5970	expect(v[50] == 28) catch @panic("test failure");
	5971	expect(v[51] == 29) catch @panic("test failure");
	5972	expect(v[52] == 30) catch @panic("test failure");
	5973	expect(v[53] == 31) catch @panic("test failure");
	5974	expect(v[54] == 32) catch @panic("test failure");
	5975	expect(v[55] == 33) catch @panic("test failure");
	5976	expect(v[56] == 34) catch @panic("test failure");
	5977	expect(v[57] == 35) catch @panic("test failure");
	5978	expect(v[58] == 36) catch @panic("test failure");
	5979	expect(v[59] == 37) catch @panic("test failure");
	5980	expect(v[60] == 38) catch @panic("test failure");
	5981	expect(v[61] == 39) catch @panic("test failure");
	5982	expect(v[62] == 40) catch @panic("test failure");
	5983	expect(v[63] == 41) catch @panic("test failure");
	5984	expect(v[64] == 42) catch @panic("test failure");
	5985	expect(v[65] == 43) catch @panic("test failure");
	5986	expect(v[66] == 44) catch @panic("test failure");
	5987	expect(v[67] == 45) catch @panic("test failure");
	5988	expect(v[68] == 46) catch @panic("test failure");
	5989	expect(v[69] == 47) catch @panic("test failure");
	5990	expect(v[70] == 48) catch @panic("test failure");
	5991	expect(v[71] == 49) catch @panic("test failure");
	5992	expect(v[72] == 50) catch @panic("test failure");
	5993	expect(v[73] == 51) catch @panic("test failure");
	5994	expect(v[74] == 52) catch @panic("test failure");
	5995	expect(v[75] == 53) catch @panic("test failure");
	5996	expect(v[76] == 54) catch @panic("test failure");
	5997	expect(v[77] == 55) catch @panic("test failure");
	5998	expect(v[78] == 56) catch @panic("test failure");
	5999	expect(v[79] == 57) catch @panic("test failure");
	6000	expect(v[80] == 58) catch @panic("test failure");
	6001	expect(v[81] == 59) catch @panic("test failure");
	6002	expect(v[82] == 60) catch @panic("test failure");
	6003	expect(v[83] == 61) catch @panic("test failure");
	6004	expect(v[84] == 62) catch @panic("test failure");
	6005	expect(v[85] == 63) catch @panic("test failure");
	6006	expect(v[86] == 64) catch @panic("test failure");
	6007	expect(v[87] == 65) catch @panic("test failure");
	6008	expect(v[88] == 66) catch @panic("test failure");
	6009	expect(v[89] == 67) catch @panic("test failure");
	6010	expect(v[90] == 68) catch @panic("test failure");
	6011	expect(v[91] == 69) catch @panic("test failure");
	6012	expect(v[92] == 70) catch @panic("test failure");
	6013	expect(v[93] == 71) catch @panic("test failure");
	6014	expect(v[94] == 72) catch @panic("test failure");
	6015	expect(v[95] == 73) catch @panic("test failure");
	6016	expect(v[96] == 74) catch @panic("test failure");
	6017	expect(v[97] == 75) catch @panic("test failure");
	6018	expect(v[98] == 76) catch @panic("test failure");
	6019	expect(v[99] == 77) catch @panic("test failure");
	6020	expect(v[100] == 78) catch @panic("test failure");
	6021	expect(v[101] == 79) catch @panic("test failure");
	6022	expect(v[102] == 80) catch @panic("test failure");
	6023	expect(v[103] == 81) catch @panic("test failure");
	6024	expect(v[104] == 82) catch @panic("test failure");
	6025	expect(v[105] == 83) catch @panic("test failure");
	6026	expect(v[106] == 84) catch @panic("test failure");
	6027	expect(v[107] == 85) catch @panic("test failure");
	6028	expect(v[108] == 86) catch @panic("test failure");
	6029	expect(v[109] == 87) catch @panic("test failure");
	6030	expect(v[110] == 88) catch @panic("test failure");
	6031	expect(v[111] == 89) catch @panic("test failure");
	6032	expect(v[112] == 90) catch @panic("test failure");
	6033	expect(v[113] == 91) catch @panic("test failure");
	6034	expect(v[114] == 92) catch @panic("test failure");
	6035	expect(v[115] == 93) catch @panic("test failure");
	6036	expect(v[116] == 94) catch @panic("test failure");
	6037	expect(v[117] == 95) catch @panic("test failure");
	6038	expect(v[118] == 96) catch @panic("test failure");
	6039	expect(v[119] == 97) catch @panic("test failure");
	6040	expect(v[120] == 98) catch @panic("test failure");
	6041	expect(v[121] == 99) catch @panic("test failure");
	6042	expect(v[122] == 0) catch @panic("test failure");
	6043	expect(v[123] == 1) catch @panic("test failure");
	6044	expect(v[124] == 2) catch @panic("test failure");
	6045	expect(v[125] == 3) catch @panic("test failure");
	6046	expect(v[126] == 4) catch @panic("test failure");
	6047	expect(v[127] == 5) catch @panic("test failure");
	6048	expect(v[128] == 6) catch @panic("test failure");
	6049	expect(v[129] == 7) catch @panic("test failure");
	6050	expect(v[130] == 8) catch @panic("test failure");
	6051	expect(v[131] == 9) catch @panic("test failure");
	6052	expect(v[132] == 10) catch @panic("test failure");
	6053	expect(v[133] == 11) catch @panic("test failure");
	6054	expect(v[134] == 12) catch @panic("test failure");
	6055	expect(v[135] == 13) catch @panic("test failure");
	6056	expect(v[136] == 14) catch @panic("test failure");
	6057	expect(v[137] == 15) catch @panic("test failure");
	6058	expect(v[138] == 16) catch @panic("test failure");
	6059	expect(v[139] == 17) catch @panic("test failure");
	6060	expect(v[140] == 18) catch @panic("test failure");
	6061	expect(v[141] == 19) catch @panic("test failure");
	6062	expect(v[142] == 20) catch @panic("test failure");
	6063	expect(v[143] == 21) catch @panic("test failure");
	6064	expect(v[144] == 22) catch @panic("test failure");
	6065	expect(v[145] == 23) catch @panic("test failure");
	6066	expect(v[146] == 24) catch @panic("test failure");
	6067	expect(v[147] == 25) catch @panic("test failure");
	6068	expect(v[148] == 26) catch @panic("test failure");
	6069	expect(v[149] == 27) catch @panic("test failure");
	6070	expect(v[150] == 28) catch @panic("test failure");
	6071	expect(v[151] == 29) catch @panic("test failure");
	6072	expect(v[152] == 30) catch @panic("test failure");
	6073	expect(v[153] == 31) catch @panic("test failure");
	6074	expect(v[154] == 32) catch @panic("test failure");
	6075	expect(v[155] == 33) catch @panic("test failure");
	6076	expect(v[156] == 34) catch @panic("test failure");
	6077	expect(v[157] == 35) catch @panic("test failure");
	6078	expect(v[158] == 36) catch @panic("test failure");
	6079	expect(v[159] == 37) catch @panic("test failure");
	6080	expect(v[160] == 38) catch @panic("test failure");
	6081	expect(v[161] == 39) catch @panic("test failure");
	6082	expect(v[162] == 40) catch @panic("test failure");
	6083	expect(v[163] == 41) catch @panic("test failure");
	6084	expect(v[164] == 42) catch @panic("test failure");
	6085	expect(v[165] == 43) catch @panic("test failure");
	6086	expect(v[166] == 44) catch @panic("test failure");
	6087	expect(v[167] == 45) catch @panic("test failure");
	6088	expect(v[168] == 46) catch @panic("test failure");
	6089	expect(v[169] == 47) catch @panic("test failure");
	6090	expect(v[170] == 48) catch @panic("test failure");
	6091	expect(v[171] == 49) catch @panic("test failure");
	6092	expect(v[172] == 50) catch @panic("test failure");
	6093	expect(v[173] == 51) catch @panic("test failure");
	6094	expect(v[174] == 52) catch @panic("test failure");
	6095	expect(v[175] == 53) catch @panic("test failure");
	6096	expect(v[176] == 54) catch @panic("test failure");
	6097	expect(v[177] == 55) catch @panic("test failure");
	6098	expect(v[178] == 56) catch @panic("test failure");
	6099	expect(v[179] == 57) catch @panic("test failure");
	6100	expect(v[180] == 58) catch @panic("test failure");
	6101	expect(v[181] == 59) catch @panic("test failure");
	6102	expect(v[182] == 60) catch @panic("test failure");
	6103	expect(v[183] == 61) catch @panic("test failure");
	6104	expect(v[184] == 62) catch @panic("test failure");
	6105	expect(v[185] == 63) catch @panic("test failure");
	6106	expect(v[186] == 64) catch @panic("test failure");
	6107	expect(v[187] == 65) catch @panic("test failure");
	6108	expect(v[188] == 66) catch @panic("test failure");
	6109	expect(v[189] == 67) catch @panic("test failure");
	6110	expect(v[190] == 68) catch @panic("test failure");
	6111	expect(v[191] == 69) catch @panic("test failure");
	6112	expect(i == 192) catch @panic("test failure");
	6113	}
	6114
	6115	extern fn c_ret_vector_192_u8() @Vector(192, u8);
	6116	extern fn c_vector_192_u8(@Vector(192, u8), usize) void;
	6117	extern fn c_test_vector_192_u8() void;
	6118
	6119	test "@Vector(192, u8)" {
	6120	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	6121	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	6122	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	6123	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	6124	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	6125
	6126	const v = c_ret_vector_192_u8();
	6127	try expect(v[0] == 70);
	6128	try expect(v[1] == 71);
	6129	try expect(v[2] == 72);
	6130	try expect(v[3] == 73);
	6131	try expect(v[4] == 74);
	6132	try expect(v[5] == 75);
	6133	try expect(v[6] == 76);
	6134	try expect(v[7] == 77);
	6135	try expect(v[8] == 78);
	6136	try expect(v[9] == 79);
	6137	try expect(v[10] == 80);
	6138	try expect(v[11] == 81);
	6139	try expect(v[12] == 82);
	6140	try expect(v[13] == 83);
	6141	try expect(v[14] == 84);
	6142	try expect(v[15] == 85);
	6143	try expect(v[16] == 86);
	6144	try expect(v[17] == 87);
	6145	try expect(v[18] == 88);
	6146	try expect(v[19] == 89);
	6147	try expect(v[20] == 90);
	6148	try expect(v[21] == 91);
	6149	try expect(v[22] == 92);
	6150	try expect(v[23] == 93);
	6151	try expect(v[24] == 94);
	6152	try expect(v[25] == 95);
	6153	try expect(v[26] == 96);
	6154	try expect(v[27] == 97);
	6155	try expect(v[28] == 98);
	6156	try expect(v[29] == 99);
	6157	try expect(v[30] == 0);
	6158	try expect(v[31] == 1);
	6159	try expect(v[32] == 2);
	6160	try expect(v[33] == 3);
	6161	try expect(v[34] == 4);
	6162	try expect(v[35] == 5);
	6163	try expect(v[36] == 6);
	6164	try expect(v[37] == 7);
	6165	try expect(v[38] == 8);
	6166	try expect(v[39] == 9);
	6167	try expect(v[40] == 10);
	6168	try expect(v[41] == 11);
	6169	try expect(v[42] == 12);
	6170	try expect(v[43] == 13);
	6171	try expect(v[44] == 14);
	6172	try expect(v[45] == 15);
	6173	try expect(v[46] == 16);
	6174	try expect(v[47] == 17);
	6175	try expect(v[48] == 18);
	6176	try expect(v[49] == 19);
	6177	try expect(v[50] == 20);
	6178	try expect(v[51] == 21);
	6179	try expect(v[52] == 22);
	6180	try expect(v[53] == 23);
	6181	try expect(v[54] == 24);
	6182	try expect(v[55] == 25);
	6183	try expect(v[56] == 26);
	6184	try expect(v[57] == 27);
	6185	try expect(v[58] == 28);
	6186	try expect(v[59] == 29);
	6187	try expect(v[60] == 30);
	6188	try expect(v[61] == 31);
	6189	try expect(v[62] == 32);
	6190	try expect(v[63] == 33);
	6191	try expect(v[64] == 34);
	6192	try expect(v[65] == 35);
	6193	try expect(v[66] == 36);
	6194	try expect(v[67] == 37);
	6195	try expect(v[68] == 38);
	6196	try expect(v[69] == 39);
	6197	try expect(v[70] == 40);
	6198	try expect(v[71] == 41);
	6199	try expect(v[72] == 42);
	6200	try expect(v[73] == 43);
	6201	try expect(v[74] == 44);
	6202	try expect(v[75] == 45);
	6203	try expect(v[76] == 46);
	6204	try expect(v[77] == 47);
	6205	try expect(v[78] == 48);
	6206	try expect(v[79] == 49);
	6207	try expect(v[80] == 50);
	6208	try expect(v[81] == 51);
	6209	try expect(v[82] == 52);
	6210	try expect(v[83] == 53);
	6211	try expect(v[84] == 54);
	6212	try expect(v[85] == 55);
	6213	try expect(v[86] == 56);
	6214	try expect(v[87] == 57);
	6215	try expect(v[88] == 58);
	6216	try expect(v[89] == 59);
	6217	try expect(v[90] == 60);
	6218	try expect(v[91] == 61);
	6219	try expect(v[92] == 62);
	6220	try expect(v[93] == 63);
	6221	try expect(v[94] == 64);
	6222	try expect(v[95] == 65);
	6223	try expect(v[96] == 66);
	6224	try expect(v[97] == 67);
	6225	try expect(v[98] == 68);
	6226	try expect(v[99] == 69);
	6227	try expect(v[100] == 70);
	6228	try expect(v[101] == 71);
	6229	try expect(v[102] == 72);
	6230	try expect(v[103] == 73);
	6231	try expect(v[104] == 74);
	6232	try expect(v[105] == 75);
	6233	try expect(v[106] == 76);
	6234	try expect(v[107] == 77);
	6235	try expect(v[108] == 78);
	6236	try expect(v[109] == 79);
	6237	try expect(v[110] == 80);
	6238	try expect(v[111] == 81);
	6239	try expect(v[112] == 82);
	6240	try expect(v[113] == 83);
	6241	try expect(v[114] == 84);
	6242	try expect(v[115] == 85);
	6243	try expect(v[116] == 86);
	6244	try expect(v[117] == 87);
	6245	try expect(v[118] == 88);
	6246	try expect(v[119] == 89);
	6247	try expect(v[120] == 90);
	6248	try expect(v[121] == 91);
	6249	try expect(v[122] == 92);
	6250	try expect(v[123] == 93);
	6251	try expect(v[124] == 94);
	6252	try expect(v[125] == 95);
	6253	try expect(v[126] == 96);
	6254	try expect(v[127] == 97);
	6255	try expect(v[128] == 98);
	6256	try expect(v[129] == 99);
	6257	try expect(v[130] == 0);
	6258	try expect(v[131] == 1);
	6259	try expect(v[132] == 2);
	6260	try expect(v[133] == 3);
	6261	try expect(v[134] == 4);
	6262	try expect(v[135] == 5);
	6263	try expect(v[136] == 6);
	6264	try expect(v[137] == 7);
	6265	try expect(v[138] == 8);
	6266	try expect(v[139] == 9);
	6267	try expect(v[140] == 10);
	6268	try expect(v[141] == 11);
	6269	try expect(v[142] == 12);
	6270	try expect(v[143] == 13);
	6271	try expect(v[144] == 14);
	6272	try expect(v[145] == 15);
	6273	try expect(v[146] == 16);
	6274	try expect(v[147] == 17);
	6275	try expect(v[148] == 18);
	6276	try expect(v[149] == 19);
	6277	try expect(v[150] == 20);
	6278	try expect(v[151] == 21);
	6279	try expect(v[152] == 22);
	6280	try expect(v[153] == 23);
	6281	try expect(v[154] == 24);
	6282	try expect(v[155] == 25);
	6283	try expect(v[156] == 26);
	6284	try expect(v[157] == 27);
	6285	try expect(v[158] == 28);
	6286	try expect(v[159] == 29);
	6287	try expect(v[160] == 30);
	6288	try expect(v[161] == 31);
	6289	try expect(v[162] == 32);
	6290	try expect(v[163] == 33);
	6291	try expect(v[164] == 34);
	6292	try expect(v[165] == 35);
	6293	try expect(v[166] == 36);
	6294	try expect(v[167] == 37);
	6295	try expect(v[168] == 38);
	6296	try expect(v[169] == 39);
	6297	try expect(v[170] == 40);
	6298	try expect(v[171] == 41);
	6299	try expect(v[172] == 42);
	6300	try expect(v[173] == 43);
	6301	try expect(v[174] == 44);
	6302	try expect(v[175] == 45);
	6303	try expect(v[176] == 46);
	6304	try expect(v[177] == 47);
	6305	try expect(v[178] == 48);
	6306	try expect(v[179] == 49);
	6307	try expect(v[180] == 50);
	6308	try expect(v[181] == 51);
	6309	try expect(v[182] == 52);
	6310	try expect(v[183] == 53);
	6311	try expect(v[184] == 54);
	6312	try expect(v[185] == 55);
	6313	try expect(v[186] == 56);
	6314	try expect(v[187] == 57);
	6315	try expect(v[188] == 58);
	6316	try expect(v[189] == 59);
	6317	try expect(v[190] == 60);
	6318	try expect(v[191] == 61);
	6319	c_vector_192_u8(.{
	6320	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	6321	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	6322	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	6323	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	6324	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	6325	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	6326	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	6327	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	6328	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	6329	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	6330	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	6331	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	6332	}, 192);
	6333	c_test_vector_192_u8();
	6334	}
	6335
	6336	export fn zig_ret_vector_256_u8() @Vector(256, u8) {
	6337	return .{
	6338	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	6339	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	6340	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	6341	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	6342	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	6343	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	6344	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	6345	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	6346	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	6347	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	6348	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	6349	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	6350	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	6351	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	6352	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	6353	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	6354	};
	6355	}
	6356	export fn zig_vector_256_u8(v: @Vector(256, u8), i: usize) void {
	6357	expect(v[0] == 10) catch @panic("test failure");
	6358	expect(v[1] == 11) catch @panic("test failure");
	6359	expect(v[2] == 12) catch @panic("test failure");
	6360	expect(v[3] == 13) catch @panic("test failure");
	6361	expect(v[4] == 14) catch @panic("test failure");
	6362	expect(v[5] == 15) catch @panic("test failure");
	6363	expect(v[6] == 16) catch @panic("test failure");
	6364	expect(v[7] == 17) catch @panic("test failure");
	6365	expect(v[8] == 18) catch @panic("test failure");
	6366	expect(v[9] == 19) catch @panic("test failure");
	6367	expect(v[10] == 20) catch @panic("test failure");
	6368	expect(v[11] == 21) catch @panic("test failure");
	6369	expect(v[12] == 22) catch @panic("test failure");
	6370	expect(v[13] == 23) catch @panic("test failure");
	6371	expect(v[14] == 24) catch @panic("test failure");
	6372	expect(v[15] == 25) catch @panic("test failure");
	6373	expect(v[16] == 26) catch @panic("test failure");
	6374	expect(v[17] == 27) catch @panic("test failure");
	6375	expect(v[18] == 28) catch @panic("test failure");
	6376	expect(v[19] == 29) catch @panic("test failure");
	6377	expect(v[20] == 30) catch @panic("test failure");
	6378	expect(v[21] == 31) catch @panic("test failure");
	6379	expect(v[22] == 32) catch @panic("test failure");
	6380	expect(v[23] == 33) catch @panic("test failure");
	6381	expect(v[24] == 34) catch @panic("test failure");
	6382	expect(v[25] == 35) catch @panic("test failure");
	6383	expect(v[26] == 36) catch @panic("test failure");
	6384	expect(v[27] == 37) catch @panic("test failure");
	6385	expect(v[28] == 38) catch @panic("test failure");
	6386	expect(v[29] == 39) catch @panic("test failure");
	6387	expect(v[30] == 40) catch @panic("test failure");
	6388	expect(v[31] == 41) catch @panic("test failure");
	6389	expect(v[32] == 42) catch @panic("test failure");
	6390	expect(v[33] == 43) catch @panic("test failure");
	6391	expect(v[34] == 44) catch @panic("test failure");
	6392	expect(v[35] == 45) catch @panic("test failure");
	6393	expect(v[36] == 46) catch @panic("test failure");
	6394	expect(v[37] == 47) catch @panic("test failure");
	6395	expect(v[38] == 48) catch @panic("test failure");
	6396	expect(v[39] == 49) catch @panic("test failure");
	6397	expect(v[40] == 50) catch @panic("test failure");
	6398	expect(v[41] == 51) catch @panic("test failure");
	6399	expect(v[42] == 52) catch @panic("test failure");
	6400	expect(v[43] == 53) catch @panic("test failure");
	6401	expect(v[44] == 54) catch @panic("test failure");
	6402	expect(v[45] == 55) catch @panic("test failure");
	6403	expect(v[46] == 56) catch @panic("test failure");
	6404	expect(v[47] == 57) catch @panic("test failure");
	6405	expect(v[48] == 58) catch @panic("test failure");
	6406	expect(v[49] == 59) catch @panic("test failure");
	6407	expect(v[50] == 60) catch @panic("test failure");
	6408	expect(v[51] == 61) catch @panic("test failure");
	6409	expect(v[52] == 62) catch @panic("test failure");
	6410	expect(v[53] == 63) catch @panic("test failure");
	6411	expect(v[54] == 64) catch @panic("test failure");
	6412	expect(v[55] == 65) catch @panic("test failure");
	6413	expect(v[56] == 66) catch @panic("test failure");
	6414	expect(v[57] == 67) catch @panic("test failure");
	6415	expect(v[58] == 68) catch @panic("test failure");
	6416	expect(v[59] == 69) catch @panic("test failure");
	6417	expect(v[60] == 70) catch @panic("test failure");
	6418	expect(v[61] == 71) catch @panic("test failure");
	6419	expect(v[62] == 72) catch @panic("test failure");
	6420	expect(v[63] == 73) catch @panic("test failure");
	6421	expect(v[64] == 74) catch @panic("test failure");
	6422	expect(v[65] == 75) catch @panic("test failure");
	6423	expect(v[66] == 76) catch @panic("test failure");
	6424	expect(v[67] == 77) catch @panic("test failure");
	6425	expect(v[68] == 78) catch @panic("test failure");
	6426	expect(v[69] == 79) catch @panic("test failure");
	6427	expect(v[70] == 80) catch @panic("test failure");
	6428	expect(v[71] == 81) catch @panic("test failure");
	6429	expect(v[72] == 82) catch @panic("test failure");
	6430	expect(v[73] == 83) catch @panic("test failure");
	6431	expect(v[74] == 84) catch @panic("test failure");
	6432	expect(v[75] == 85) catch @panic("test failure");
	6433	expect(v[76] == 86) catch @panic("test failure");
	6434	expect(v[77] == 87) catch @panic("test failure");
	6435	expect(v[78] == 88) catch @panic("test failure");
	6436	expect(v[79] == 89) catch @panic("test failure");
	6437	expect(v[80] == 90) catch @panic("test failure");
	6438	expect(v[81] == 91) catch @panic("test failure");
	6439	expect(v[82] == 92) catch @panic("test failure");
	6440	expect(v[83] == 93) catch @panic("test failure");
	6441	expect(v[84] == 94) catch @panic("test failure");
	6442	expect(v[85] == 95) catch @panic("test failure");
	6443	expect(v[86] == 96) catch @panic("test failure");
	6444	expect(v[87] == 97) catch @panic("test failure");
	6445	expect(v[88] == 98) catch @panic("test failure");
	6446	expect(v[89] == 99) catch @panic("test failure");
	6447	expect(v[90] == 0) catch @panic("test failure");
	6448	expect(v[91] == 1) catch @panic("test failure");
	6449	expect(v[92] == 2) catch @panic("test failure");
	6450	expect(v[93] == 3) catch @panic("test failure");
	6451	expect(v[94] == 4) catch @panic("test failure");
	6452	expect(v[95] == 5) catch @panic("test failure");
	6453	expect(v[96] == 6) catch @panic("test failure");
	6454	expect(v[97] == 7) catch @panic("test failure");
	6455	expect(v[98] == 8) catch @panic("test failure");
	6456	expect(v[99] == 9) catch @panic("test failure");
	6457	expect(v[100] == 10) catch @panic("test failure");
	6458	expect(v[101] == 11) catch @panic("test failure");
	6459	expect(v[102] == 12) catch @panic("test failure");
	6460	expect(v[103] == 13) catch @panic("test failure");
	6461	expect(v[104] == 14) catch @panic("test failure");
	6462	expect(v[105] == 15) catch @panic("test failure");
	6463	expect(v[106] == 16) catch @panic("test failure");
	6464	expect(v[107] == 17) catch @panic("test failure");
	6465	expect(v[108] == 18) catch @panic("test failure");
	6466	expect(v[109] == 19) catch @panic("test failure");
	6467	expect(v[110] == 20) catch @panic("test failure");
	6468	expect(v[111] == 21) catch @panic("test failure");
	6469	expect(v[112] == 22) catch @panic("test failure");
	6470	expect(v[113] == 23) catch @panic("test failure");
	6471	expect(v[114] == 24) catch @panic("test failure");
	6472	expect(v[115] == 25) catch @panic("test failure");
	6473	expect(v[116] == 26) catch @panic("test failure");
	6474	expect(v[117] == 27) catch @panic("test failure");
	6475	expect(v[118] == 28) catch @panic("test failure");
	6476	expect(v[119] == 29) catch @panic("test failure");
	6477	expect(v[120] == 30) catch @panic("test failure");
	6478	expect(v[121] == 31) catch @panic("test failure");
	6479	expect(v[122] == 32) catch @panic("test failure");
	6480	expect(v[123] == 33) catch @panic("test failure");
	6481	expect(v[124] == 34) catch @panic("test failure");
	6482	expect(v[125] == 35) catch @panic("test failure");
	6483	expect(v[126] == 36) catch @panic("test failure");
	6484	expect(v[127] == 37) catch @panic("test failure");
	6485	expect(v[128] == 38) catch @panic("test failure");
	6486	expect(v[129] == 39) catch @panic("test failure");
	6487	expect(v[130] == 40) catch @panic("test failure");
	6488	expect(v[131] == 41) catch @panic("test failure");
	6489	expect(v[132] == 42) catch @panic("test failure");
	6490	expect(v[133] == 43) catch @panic("test failure");
	6491	expect(v[134] == 44) catch @panic("test failure");
	6492	expect(v[135] == 45) catch @panic("test failure");
	6493	expect(v[136] == 46) catch @panic("test failure");
	6494	expect(v[137] == 47) catch @panic("test failure");
	6495	expect(v[138] == 48) catch @panic("test failure");
	6496	expect(v[139] == 49) catch @panic("test failure");
	6497	expect(v[140] == 50) catch @panic("test failure");
	6498	expect(v[141] == 51) catch @panic("test failure");
	6499	expect(v[142] == 52) catch @panic("test failure");
	6500	expect(v[143] == 53) catch @panic("test failure");
	6501	expect(v[144] == 54) catch @panic("test failure");
	6502	expect(v[145] == 55) catch @panic("test failure");
	6503	expect(v[146] == 56) catch @panic("test failure");
	6504	expect(v[147] == 57) catch @panic("test failure");
	6505	expect(v[148] == 58) catch @panic("test failure");
	6506	expect(v[149] == 59) catch @panic("test failure");
	6507	expect(v[150] == 60) catch @panic("test failure");
	6508	expect(v[151] == 61) catch @panic("test failure");
	6509	expect(v[152] == 62) catch @panic("test failure");
	6510	expect(v[153] == 63) catch @panic("test failure");
	6511	expect(v[154] == 64) catch @panic("test failure");
	6512	expect(v[155] == 65) catch @panic("test failure");
	6513	expect(v[156] == 66) catch @panic("test failure");
	6514	expect(v[157] == 67) catch @panic("test failure");
	6515	expect(v[158] == 68) catch @panic("test failure");
	6516	expect(v[159] == 69) catch @panic("test failure");
	6517	expect(v[160] == 70) catch @panic("test failure");
	6518	expect(v[161] == 71) catch @panic("test failure");
	6519	expect(v[162] == 72) catch @panic("test failure");
	6520	expect(v[163] == 73) catch @panic("test failure");
	6521	expect(v[164] == 74) catch @panic("test failure");
	6522	expect(v[165] == 75) catch @panic("test failure");
	6523	expect(v[166] == 76) catch @panic("test failure");
	6524	expect(v[167] == 77) catch @panic("test failure");
	6525	expect(v[168] == 78) catch @panic("test failure");
	6526	expect(v[169] == 79) catch @panic("test failure");
	6527	expect(v[170] == 80) catch @panic("test failure");
	6528	expect(v[171] == 81) catch @panic("test failure");
	6529	expect(v[172] == 82) catch @panic("test failure");
	6530	expect(v[173] == 83) catch @panic("test failure");
	6531	expect(v[174] == 84) catch @panic("test failure");
	6532	expect(v[175] == 85) catch @panic("test failure");
	6533	expect(v[176] == 86) catch @panic("test failure");
	6534	expect(v[177] == 87) catch @panic("test failure");
	6535	expect(v[178] == 88) catch @panic("test failure");
	6536	expect(v[179] == 89) catch @panic("test failure");
	6537	expect(v[180] == 90) catch @panic("test failure");
	6538	expect(v[181] == 91) catch @panic("test failure");
	6539	expect(v[182] == 92) catch @panic("test failure");
	6540	expect(v[183] == 93) catch @panic("test failure");
	6541	expect(v[184] == 94) catch @panic("test failure");
	6542	expect(v[185] == 95) catch @panic("test failure");
	6543	expect(v[186] == 96) catch @panic("test failure");
	6544	expect(v[187] == 97) catch @panic("test failure");
	6545	expect(v[188] == 98) catch @panic("test failure");
	6546	expect(v[189] == 99) catch @panic("test failure");
	6547	expect(v[190] == 0) catch @panic("test failure");
	6548	expect(v[191] == 1) catch @panic("test failure");
	6549	expect(v[192] == 2) catch @panic("test failure");
	6550	expect(v[193] == 3) catch @panic("test failure");
	6551	expect(v[194] == 4) catch @panic("test failure");
	6552	expect(v[195] == 5) catch @panic("test failure");
	6553	expect(v[196] == 6) catch @panic("test failure");
	6554	expect(v[197] == 7) catch @panic("test failure");
	6555	expect(v[198] == 8) catch @panic("test failure");
	6556	expect(v[199] == 9) catch @panic("test failure");
	6557	expect(v[200] == 10) catch @panic("test failure");
	6558	expect(v[201] == 11) catch @panic("test failure");
	6559	expect(v[202] == 12) catch @panic("test failure");
	6560	expect(v[203] == 13) catch @panic("test failure");
	6561	expect(v[204] == 14) catch @panic("test failure");
	6562	expect(v[205] == 15) catch @panic("test failure");
	6563	expect(v[206] == 16) catch @panic("test failure");
	6564	expect(v[207] == 17) catch @panic("test failure");
	6565	expect(v[208] == 18) catch @panic("test failure");
	6566	expect(v[209] == 19) catch @panic("test failure");
	6567	expect(v[210] == 20) catch @panic("test failure");
	6568	expect(v[211] == 21) catch @panic("test failure");
	6569	expect(v[212] == 22) catch @panic("test failure");
	6570	expect(v[213] == 23) catch @panic("test failure");
	6571	expect(v[214] == 24) catch @panic("test failure");
	6572	expect(v[215] == 25) catch @panic("test failure");
	6573	expect(v[216] == 26) catch @panic("test failure");
	6574	expect(v[217] == 27) catch @panic("test failure");
	6575	expect(v[218] == 28) catch @panic("test failure");
	6576	expect(v[219] == 29) catch @panic("test failure");
	6577	expect(v[220] == 30) catch @panic("test failure");
	6578	expect(v[221] == 31) catch @panic("test failure");
	6579	expect(v[222] == 32) catch @panic("test failure");
	6580	expect(v[223] == 33) catch @panic("test failure");
	6581	expect(v[224] == 34) catch @panic("test failure");
	6582	expect(v[225] == 35) catch @panic("test failure");
	6583	expect(v[226] == 36) catch @panic("test failure");
	6584	expect(v[227] == 37) catch @panic("test failure");
	6585	expect(v[228] == 38) catch @panic("test failure");
	6586	expect(v[229] == 39) catch @panic("test failure");
	6587	expect(v[230] == 40) catch @panic("test failure");
	6588	expect(v[231] == 41) catch @panic("test failure");
	6589	expect(v[232] == 42) catch @panic("test failure");
	6590	expect(v[233] == 43) catch @panic("test failure");
	6591	expect(v[234] == 44) catch @panic("test failure");
	6592	expect(v[235] == 45) catch @panic("test failure");
	6593	expect(v[236] == 46) catch @panic("test failure");
	6594	expect(v[237] == 47) catch @panic("test failure");
	6595	expect(v[238] == 48) catch @panic("test failure");
	6596	expect(v[239] == 49) catch @panic("test failure");
	6597	expect(v[240] == 50) catch @panic("test failure");
	6598	expect(v[241] == 51) catch @panic("test failure");
	6599	expect(v[242] == 52) catch @panic("test failure");
	6600	expect(v[243] == 53) catch @panic("test failure");
	6601	expect(v[244] == 54) catch @panic("test failure");
	6602	expect(v[245] == 55) catch @panic("test failure");
	6603	expect(v[246] == 56) catch @panic("test failure");
	6604	expect(v[247] == 57) catch @panic("test failure");
	6605	expect(v[248] == 58) catch @panic("test failure");
	6606	expect(v[249] == 59) catch @panic("test failure");
	6607	expect(v[250] == 60) catch @panic("test failure");
	6608	expect(v[251] == 61) catch @panic("test failure");
	6609	expect(v[252] == 62) catch @panic("test failure");
	6610	expect(v[253] == 63) catch @panic("test failure");
	6611	expect(v[254] == 64) catch @panic("test failure");
	6612	expect(v[255] == 65) catch @panic("test failure");
	6613	expect(i == 256) catch @panic("test failure");
	6614	}
	6615
	6616	extern fn c_ret_vector_256_u8() @Vector(256, u8);
	6617	extern fn c_vector_256_u8(@Vector(256, u8), usize) void;
	6618	extern fn c_test_vector_256_u8() void;
	6619
	6620	test "@Vector(256, u8)" {
	6621	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	6622	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	6623	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	6624	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	6625	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	6626
	6627	const v = c_ret_vector_256_u8();
	6628	try expect(v[0] == 66);
	6629	try expect(v[1] == 67);
	6630	try expect(v[2] == 68);
	6631	try expect(v[3] == 69);
	6632	try expect(v[4] == 70);
	6633	try expect(v[5] == 71);
	6634	try expect(v[6] == 72);
	6635	try expect(v[7] == 73);
	6636	try expect(v[8] == 74);
	6637	try expect(v[9] == 75);
	6638	try expect(v[10] == 76);
	6639	try expect(v[11] == 77);
	6640	try expect(v[12] == 78);
	6641	try expect(v[13] == 79);
	6642	try expect(v[14] == 80);
	6643	try expect(v[15] == 81);
	6644	try expect(v[16] == 82);
	6645	try expect(v[17] == 83);
	6646	try expect(v[18] == 84);
	6647	try expect(v[19] == 85);
	6648	try expect(v[20] == 86);
	6649	try expect(v[21] == 87);
	6650	try expect(v[22] == 88);
	6651	try expect(v[23] == 89);
	6652	try expect(v[24] == 90);
	6653	try expect(v[25] == 91);
	6654	try expect(v[26] == 92);
	6655	try expect(v[27] == 93);
	6656	try expect(v[28] == 94);
	6657	try expect(v[29] == 95);
	6658	try expect(v[30] == 96);
	6659	try expect(v[31] == 97);
	6660	try expect(v[32] == 98);
	6661	try expect(v[33] == 99);
	6662	try expect(v[34] == 0);
	6663	try expect(v[35] == 1);
	6664	try expect(v[36] == 2);
	6665	try expect(v[37] == 3);
	6666	try expect(v[38] == 4);
	6667	try expect(v[39] == 5);
	6668	try expect(v[40] == 6);
	6669	try expect(v[41] == 7);
	6670	try expect(v[42] == 8);
	6671	try expect(v[43] == 9);
	6672	try expect(v[44] == 10);
	6673	try expect(v[45] == 11);
	6674	try expect(v[46] == 12);
	6675	try expect(v[47] == 13);
	6676	try expect(v[48] == 14);
	6677	try expect(v[49] == 15);
	6678	try expect(v[50] == 16);
	6679	try expect(v[51] == 17);
	6680	try expect(v[52] == 18);
	6681	try expect(v[53] == 19);
	6682	try expect(v[54] == 20);
	6683	try expect(v[55] == 21);
	6684	try expect(v[56] == 22);
	6685	try expect(v[57] == 23);
	6686	try expect(v[58] == 24);
	6687	try expect(v[59] == 25);
	6688	try expect(v[60] == 26);
	6689	try expect(v[61] == 27);
	6690	try expect(v[62] == 28);
	6691	try expect(v[63] == 29);
	6692	try expect(v[64] == 30);
	6693	try expect(v[65] == 31);
	6694	try expect(v[66] == 32);
	6695	try expect(v[67] == 33);
	6696	try expect(v[68] == 34);
	6697	try expect(v[69] == 35);
	6698	try expect(v[70] == 36);
	6699	try expect(v[71] == 37);
	6700	try expect(v[72] == 38);
	6701	try expect(v[73] == 39);
	6702	try expect(v[74] == 40);
	6703	try expect(v[75] == 41);
	6704	try expect(v[76] == 42);
	6705	try expect(v[77] == 43);
	6706	try expect(v[78] == 44);
	6707	try expect(v[79] == 45);
	6708	try expect(v[80] == 46);
	6709	try expect(v[81] == 47);
	6710	try expect(v[82] == 48);
	6711	try expect(v[83] == 49);
	6712	try expect(v[84] == 50);
	6713	try expect(v[85] == 51);
	6714	try expect(v[86] == 52);
	6715	try expect(v[87] == 53);
	6716	try expect(v[88] == 54);
	6717	try expect(v[89] == 55);
	6718	try expect(v[90] == 56);
	6719	try expect(v[91] == 57);
	6720	try expect(v[92] == 58);
	6721	try expect(v[93] == 59);
	6722	try expect(v[94] == 60);
	6723	try expect(v[95] == 61);
	6724	try expect(v[96] == 62);
	6725	try expect(v[97] == 63);
	6726	try expect(v[98] == 64);
	6727	try expect(v[99] == 65);
	6728	try expect(v[100] == 66);
	6729	try expect(v[101] == 67);
	6730	try expect(v[102] == 68);
	6731	try expect(v[103] == 69);
	6732	try expect(v[104] == 70);
	6733	try expect(v[105] == 71);
	6734	try expect(v[106] == 72);
	6735	try expect(v[107] == 73);
	6736	try expect(v[108] == 74);
	6737	try expect(v[109] == 75);
	6738	try expect(v[110] == 76);
	6739	try expect(v[111] == 77);
	6740	try expect(v[112] == 78);
	6741	try expect(v[113] == 79);
	6742	try expect(v[114] == 80);
	6743	try expect(v[115] == 81);
	6744	try expect(v[116] == 82);
	6745	try expect(v[117] == 83);
	6746	try expect(v[118] == 84);
	6747	try expect(v[119] == 85);
	6748	try expect(v[120] == 86);
	6749	try expect(v[121] == 87);
	6750	try expect(v[122] == 88);
	6751	try expect(v[123] == 89);
	6752	try expect(v[124] == 90);
	6753	try expect(v[125] == 91);
	6754	try expect(v[126] == 92);
	6755	try expect(v[127] == 93);
	6756	try expect(v[128] == 94);
	6757	try expect(v[129] == 95);
	6758	try expect(v[130] == 96);
	6759	try expect(v[131] == 97);
	6760	try expect(v[132] == 98);
	6761	try expect(v[133] == 99);
	6762	try expect(v[134] == 0);
	6763	try expect(v[135] == 1);
	6764	try expect(v[136] == 2);
	6765	try expect(v[137] == 3);
	6766	try expect(v[138] == 4);
	6767	try expect(v[139] == 5);
	6768	try expect(v[140] == 6);
	6769	try expect(v[141] == 7);
	6770	try expect(v[142] == 8);
	6771	try expect(v[143] == 9);
	6772	try expect(v[144] == 10);
	6773	try expect(v[145] == 11);
	6774	try expect(v[146] == 12);
	6775	try expect(v[147] == 13);
	6776	try expect(v[148] == 14);
	6777	try expect(v[149] == 15);
	6778	try expect(v[150] == 16);
	6779	try expect(v[151] == 17);
	6780	try expect(v[152] == 18);
	6781	try expect(v[153] == 19);
	6782	try expect(v[154] == 20);
	6783	try expect(v[155] == 21);
	6784	try expect(v[156] == 22);
	6785	try expect(v[157] == 23);
	6786	try expect(v[158] == 24);
	6787	try expect(v[159] == 25);
	6788	try expect(v[160] == 26);
	6789	try expect(v[161] == 27);
	6790	try expect(v[162] == 28);
	6791	try expect(v[163] == 29);
	6792	try expect(v[164] == 30);
	6793	try expect(v[165] == 31);
	6794	try expect(v[166] == 32);
	6795	try expect(v[167] == 33);
	6796	try expect(v[168] == 34);
	6797	try expect(v[169] == 35);
	6798	try expect(v[170] == 36);
	6799	try expect(v[171] == 37);
	6800	try expect(v[172] == 38);
	6801	try expect(v[173] == 39);
	6802	try expect(v[174] == 40);
	6803	try expect(v[175] == 41);
	6804	try expect(v[176] == 42);
	6805	try expect(v[177] == 43);
	6806	try expect(v[178] == 44);
	6807	try expect(v[179] == 45);
	6808	try expect(v[180] == 46);
	6809	try expect(v[181] == 47);
	6810	try expect(v[182] == 48);
	6811	try expect(v[183] == 49);
	6812	try expect(v[184] == 50);
	6813	try expect(v[185] == 51);
	6814	try expect(v[186] == 52);
	6815	try expect(v[187] == 53);
	6816	try expect(v[188] == 54);
	6817	try expect(v[189] == 55);
	6818	try expect(v[190] == 56);
	6819	try expect(v[191] == 57);
	6820	try expect(v[192] == 58);
	6821	try expect(v[193] == 59);
	6822	try expect(v[194] == 60);
	6823	try expect(v[195] == 61);
	6824	try expect(v[196] == 62);
	6825	try expect(v[197] == 63);
	6826	try expect(v[198] == 64);
	6827	try expect(v[199] == 65);
	6828	try expect(v[200] == 66);
	6829	try expect(v[201] == 67);
	6830	try expect(v[202] == 68);
	6831	try expect(v[203] == 69);
	6832	try expect(v[204] == 70);
	6833	try expect(v[205] == 71);
	6834	try expect(v[206] == 72);
	6835	try expect(v[207] == 73);
	6836	try expect(v[208] == 74);
	6837	try expect(v[209] == 75);
	6838	try expect(v[210] == 76);
	6839	try expect(v[211] == 77);
	6840	try expect(v[212] == 78);
	6841	try expect(v[213] == 79);
	6842	try expect(v[214] == 80);
	6843	try expect(v[215] == 81);
	6844	try expect(v[216] == 82);
	6845	try expect(v[217] == 83);
	6846	try expect(v[218] == 84);
	6847	try expect(v[219] == 85);
	6848	try expect(v[220] == 86);
	6849	try expect(v[221] == 87);
	6850	try expect(v[222] == 88);
	6851	try expect(v[223] == 89);
	6852	try expect(v[224] == 90);
	6853	try expect(v[225] == 91);
	6854	try expect(v[226] == 92);
	6855	try expect(v[227] == 93);
	6856	try expect(v[228] == 94);
	6857	try expect(v[229] == 95);
	6858	try expect(v[230] == 96);
	6859	try expect(v[231] == 97);
	6860	try expect(v[232] == 98);
	6861	try expect(v[233] == 99);
	6862	try expect(v[234] == 0);
	6863	try expect(v[235] == 1);
	6864	try expect(v[236] == 2);
	6865	try expect(v[237] == 3);
	6866	try expect(v[238] == 4);
	6867	try expect(v[239] == 5);
	6868	try expect(v[240] == 6);
	6869	try expect(v[241] == 7);
	6870	try expect(v[242] == 8);
	6871	try expect(v[243] == 9);
	6872	try expect(v[244] == 10);
	6873	try expect(v[245] == 11);
	6874	try expect(v[246] == 12);
	6875	try expect(v[247] == 13);
	6876	try expect(v[248] == 14);
	6877	try expect(v[249] == 15);
	6878	try expect(v[250] == 16);
	6879	try expect(v[251] == 17);
	6880	try expect(v[252] == 18);
	6881	try expect(v[253] == 19);
	6882	try expect(v[254] == 20);
	6883	try expect(v[255] == 21);
	6884	c_vector_256_u8(.{
	6885	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	6886	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	6887	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	6888	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	6889	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	6890	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	6891	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	6892	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	6893	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	6894	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	6895	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	6896	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	6897	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	6898	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	6899	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	6900	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	6901	}, 256);
	6902	c_test_vector_256_u8();
	6903	}
	6904
	6905	export fn zig_ret_vector_384_u8() @Vector(384, u8) {
	6906	return .{
	6907	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	6908	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	6909	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	6910	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	6911	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	6912	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	6913	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	6914	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	6915	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	6916	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	6917	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	6918	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	6919	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	6920	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	6921	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	6922	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	6923	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	6924	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	6925	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	6926	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	6927	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	6928	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	6929	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	6930	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	6931	};
	6932	}
	6933	export fn zig_vector_384_u8(v: @Vector(384, u8), i: usize) void {
	6934	expect(v[0] == 62) catch @panic("test failure");
	6935	expect(v[1] == 63) catch @panic("test failure");
	6936	expect(v[2] == 64) catch @panic("test failure");
	6937	expect(v[3] == 65) catch @panic("test failure");
	6938	expect(v[4] == 66) catch @panic("test failure");
	6939	expect(v[5] == 67) catch @panic("test failure");
	6940	expect(v[6] == 68) catch @panic("test failure");
	6941	expect(v[7] == 69) catch @panic("test failure");
	6942	expect(v[8] == 70) catch @panic("test failure");
	6943	expect(v[9] == 71) catch @panic("test failure");
	6944	expect(v[10] == 72) catch @panic("test failure");
	6945	expect(v[11] == 73) catch @panic("test failure");
	6946	expect(v[12] == 74) catch @panic("test failure");
	6947	expect(v[13] == 75) catch @panic("test failure");
	6948	expect(v[14] == 76) catch @panic("test failure");
	6949	expect(v[15] == 77) catch @panic("test failure");
	6950	expect(v[16] == 78) catch @panic("test failure");
	6951	expect(v[17] == 79) catch @panic("test failure");
	6952	expect(v[18] == 80) catch @panic("test failure");
	6953	expect(v[19] == 81) catch @panic("test failure");
	6954	expect(v[20] == 82) catch @panic("test failure");
	6955	expect(v[21] == 83) catch @panic("test failure");
	6956	expect(v[22] == 84) catch @panic("test failure");
	6957	expect(v[23] == 85) catch @panic("test failure");
	6958	expect(v[24] == 86) catch @panic("test failure");
	6959	expect(v[25] == 87) catch @panic("test failure");
	6960	expect(v[26] == 88) catch @panic("test failure");
	6961	expect(v[27] == 89) catch @panic("test failure");
	6962	expect(v[28] == 90) catch @panic("test failure");
	6963	expect(v[29] == 91) catch @panic("test failure");
	6964	expect(v[30] == 92) catch @panic("test failure");
	6965	expect(v[31] == 93) catch @panic("test failure");
	6966	expect(v[32] == 94) catch @panic("test failure");
	6967	expect(v[33] == 95) catch @panic("test failure");
	6968	expect(v[34] == 96) catch @panic("test failure");
	6969	expect(v[35] == 97) catch @panic("test failure");
	6970	expect(v[36] == 98) catch @panic("test failure");
	6971	expect(v[37] == 99) catch @panic("test failure");
	6972	expect(v[38] == 0) catch @panic("test failure");
	6973	expect(v[39] == 1) catch @panic("test failure");
	6974	expect(v[40] == 2) catch @panic("test failure");
	6975	expect(v[41] == 3) catch @panic("test failure");
	6976	expect(v[42] == 4) catch @panic("test failure");
	6977	expect(v[43] == 5) catch @panic("test failure");
	6978	expect(v[44] == 6) catch @panic("test failure");
	6979	expect(v[45] == 7) catch @panic("test failure");
	6980	expect(v[46] == 8) catch @panic("test failure");
	6981	expect(v[47] == 9) catch @panic("test failure");
	6982	expect(v[48] == 10) catch @panic("test failure");
	6983	expect(v[49] == 11) catch @panic("test failure");
	6984	expect(v[50] == 12) catch @panic("test failure");
	6985	expect(v[51] == 13) catch @panic("test failure");
	6986	expect(v[52] == 14) catch @panic("test failure");
	6987	expect(v[53] == 15) catch @panic("test failure");
	6988	expect(v[54] == 16) catch @panic("test failure");
	6989	expect(v[55] == 17) catch @panic("test failure");
	6990	expect(v[56] == 18) catch @panic("test failure");
	6991	expect(v[57] == 19) catch @panic("test failure");
	6992	expect(v[58] == 20) catch @panic("test failure");
	6993	expect(v[59] == 21) catch @panic("test failure");
	6994	expect(v[60] == 22) catch @panic("test failure");
	6995	expect(v[61] == 23) catch @panic("test failure");
	6996	expect(v[62] == 24) catch @panic("test failure");
	6997	expect(v[63] == 25) catch @panic("test failure");
	6998	expect(v[64] == 26) catch @panic("test failure");
	6999	expect(v[65] == 27) catch @panic("test failure");
	7000	expect(v[66] == 28) catch @panic("test failure");
	7001	expect(v[67] == 29) catch @panic("test failure");
	7002	expect(v[68] == 30) catch @panic("test failure");
	7003	expect(v[69] == 31) catch @panic("test failure");
	7004	expect(v[70] == 32) catch @panic("test failure");
	7005	expect(v[71] == 33) catch @panic("test failure");
	7006	expect(v[72] == 34) catch @panic("test failure");
	7007	expect(v[73] == 35) catch @panic("test failure");
	7008	expect(v[74] == 36) catch @panic("test failure");
	7009	expect(v[75] == 37) catch @panic("test failure");
	7010	expect(v[76] == 38) catch @panic("test failure");
	7011	expect(v[77] == 39) catch @panic("test failure");
	7012	expect(v[78] == 40) catch @panic("test failure");
	7013	expect(v[79] == 41) catch @panic("test failure");
	7014	expect(v[80] == 42) catch @panic("test failure");
	7015	expect(v[81] == 43) catch @panic("test failure");
	7016	expect(v[82] == 44) catch @panic("test failure");
	7017	expect(v[83] == 45) catch @panic("test failure");
	7018	expect(v[84] == 46) catch @panic("test failure");
	7019	expect(v[85] == 47) catch @panic("test failure");
	7020	expect(v[86] == 48) catch @panic("test failure");
	7021	expect(v[87] == 49) catch @panic("test failure");
	7022	expect(v[88] == 50) catch @panic("test failure");
	7023	expect(v[89] == 51) catch @panic("test failure");
	7024	expect(v[90] == 52) catch @panic("test failure");
	7025	expect(v[91] == 53) catch @panic("test failure");
	7026	expect(v[92] == 54) catch @panic("test failure");
	7027	expect(v[93] == 55) catch @panic("test failure");
	7028	expect(v[94] == 56) catch @panic("test failure");
	7029	expect(v[95] == 57) catch @panic("test failure");
	7030	expect(v[96] == 58) catch @panic("test failure");
	7031	expect(v[97] == 59) catch @panic("test failure");
	7032	expect(v[98] == 60) catch @panic("test failure");
	7033	expect(v[99] == 61) catch @panic("test failure");
	7034	expect(v[100] == 62) catch @panic("test failure");
	7035	expect(v[101] == 63) catch @panic("test failure");
	7036	expect(v[102] == 64) catch @panic("test failure");
	7037	expect(v[103] == 65) catch @panic("test failure");
	7038	expect(v[104] == 66) catch @panic("test failure");
	7039	expect(v[105] == 67) catch @panic("test failure");
	7040	expect(v[106] == 68) catch @panic("test failure");
	7041	expect(v[107] == 69) catch @panic("test failure");
	7042	expect(v[108] == 70) catch @panic("test failure");
	7043	expect(v[109] == 71) catch @panic("test failure");
	7044	expect(v[110] == 72) catch @panic("test failure");
	7045	expect(v[111] == 73) catch @panic("test failure");
	7046	expect(v[112] == 74) catch @panic("test failure");
	7047	expect(v[113] == 75) catch @panic("test failure");
	7048	expect(v[114] == 76) catch @panic("test failure");
	7049	expect(v[115] == 77) catch @panic("test failure");
	7050	expect(v[116] == 78) catch @panic("test failure");
	7051	expect(v[117] == 79) catch @panic("test failure");
	7052	expect(v[118] == 80) catch @panic("test failure");
	7053	expect(v[119] == 81) catch @panic("test failure");
	7054	expect(v[120] == 82) catch @panic("test failure");
	7055	expect(v[121] == 83) catch @panic("test failure");
	7056	expect(v[122] == 84) catch @panic("test failure");
	7057	expect(v[123] == 85) catch @panic("test failure");
	7058	expect(v[124] == 86) catch @panic("test failure");
	7059	expect(v[125] == 87) catch @panic("test failure");
	7060	expect(v[126] == 88) catch @panic("test failure");
	7061	expect(v[127] == 89) catch @panic("test failure");
	7062	expect(v[128] == 90) catch @panic("test failure");
	7063	expect(v[129] == 91) catch @panic("test failure");
	7064	expect(v[130] == 92) catch @panic("test failure");
	7065	expect(v[131] == 93) catch @panic("test failure");
	7066	expect(v[132] == 94) catch @panic("test failure");
	7067	expect(v[133] == 95) catch @panic("test failure");
	7068	expect(v[134] == 96) catch @panic("test failure");
	7069	expect(v[135] == 97) catch @panic("test failure");
	7070	expect(v[136] == 98) catch @panic("test failure");
	7071	expect(v[137] == 99) catch @panic("test failure");
	7072	expect(v[138] == 0) catch @panic("test failure");
	7073	expect(v[139] == 1) catch @panic("test failure");
	7074	expect(v[140] == 2) catch @panic("test failure");
	7075	expect(v[141] == 3) catch @panic("test failure");
	7076	expect(v[142] == 4) catch @panic("test failure");
	7077	expect(v[143] == 5) catch @panic("test failure");
	7078	expect(v[144] == 6) catch @panic("test failure");
	7079	expect(v[145] == 7) catch @panic("test failure");
	7080	expect(v[146] == 8) catch @panic("test failure");
	7081	expect(v[147] == 9) catch @panic("test failure");
	7082	expect(v[148] == 10) catch @panic("test failure");
	7083	expect(v[149] == 11) catch @panic("test failure");
	7084	expect(v[150] == 12) catch @panic("test failure");
	7085	expect(v[151] == 13) catch @panic("test failure");
	7086	expect(v[152] == 14) catch @panic("test failure");
	7087	expect(v[153] == 15) catch @panic("test failure");
	7088	expect(v[154] == 16) catch @panic("test failure");
	7089	expect(v[155] == 17) catch @panic("test failure");
	7090	expect(v[156] == 18) catch @panic("test failure");
	7091	expect(v[157] == 19) catch @panic("test failure");
	7092	expect(v[158] == 20) catch @panic("test failure");
	7093	expect(v[159] == 21) catch @panic("test failure");
	7094	expect(v[160] == 22) catch @panic("test failure");
	7095	expect(v[161] == 23) catch @panic("test failure");
	7096	expect(v[162] == 24) catch @panic("test failure");
	7097	expect(v[163] == 25) catch @panic("test failure");
	7098	expect(v[164] == 26) catch @panic("test failure");
	7099	expect(v[165] == 27) catch @panic("test failure");
	7100	expect(v[166] == 28) catch @panic("test failure");
	7101	expect(v[167] == 29) catch @panic("test failure");
	7102	expect(v[168] == 30) catch @panic("test failure");
	7103	expect(v[169] == 31) catch @panic("test failure");
	7104	expect(v[170] == 32) catch @panic("test failure");
	7105	expect(v[171] == 33) catch @panic("test failure");
	7106	expect(v[172] == 34) catch @panic("test failure");
	7107	expect(v[173] == 35) catch @panic("test failure");
	7108	expect(v[174] == 36) catch @panic("test failure");
	7109	expect(v[175] == 37) catch @panic("test failure");
	7110	expect(v[176] == 38) catch @panic("test failure");
	7111	expect(v[177] == 39) catch @panic("test failure");
	7112	expect(v[178] == 40) catch @panic("test failure");
	7113	expect(v[179] == 41) catch @panic("test failure");
	7114	expect(v[180] == 42) catch @panic("test failure");
	7115	expect(v[181] == 43) catch @panic("test failure");
	7116	expect(v[182] == 44) catch @panic("test failure");
	7117	expect(v[183] == 45) catch @panic("test failure");
	7118	expect(v[184] == 46) catch @panic("test failure");
	7119	expect(v[185] == 47) catch @panic("test failure");
	7120	expect(v[186] == 48) catch @panic("test failure");
	7121	expect(v[187] == 49) catch @panic("test failure");
	7122	expect(v[188] == 50) catch @panic("test failure");
	7123	expect(v[189] == 51) catch @panic("test failure");
	7124	expect(v[190] == 52) catch @panic("test failure");
	7125	expect(v[191] == 53) catch @panic("test failure");
	7126	expect(v[192] == 54) catch @panic("test failure");
	7127	expect(v[193] == 55) catch @panic("test failure");
	7128	expect(v[194] == 56) catch @panic("test failure");
	7129	expect(v[195] == 57) catch @panic("test failure");
	7130	expect(v[196] == 58) catch @panic("test failure");
	7131	expect(v[197] == 59) catch @panic("test failure");
	7132	expect(v[198] == 60) catch @panic("test failure");
	7133	expect(v[199] == 61) catch @panic("test failure");
	7134	expect(v[200] == 62) catch @panic("test failure");
	7135	expect(v[201] == 63) catch @panic("test failure");
	7136	expect(v[202] == 64) catch @panic("test failure");
	7137	expect(v[203] == 65) catch @panic("test failure");
	7138	expect(v[204] == 66) catch @panic("test failure");
	7139	expect(v[205] == 67) catch @panic("test failure");
	7140	expect(v[206] == 68) catch @panic("test failure");
	7141	expect(v[207] == 69) catch @panic("test failure");
	7142	expect(v[208] == 70) catch @panic("test failure");
	7143	expect(v[209] == 71) catch @panic("test failure");
	7144	expect(v[210] == 72) catch @panic("test failure");
	7145	expect(v[211] == 73) catch @panic("test failure");
	7146	expect(v[212] == 74) catch @panic("test failure");
	7147	expect(v[213] == 75) catch @panic("test failure");
	7148	expect(v[214] == 76) catch @panic("test failure");
	7149	expect(v[215] == 77) catch @panic("test failure");
	7150	expect(v[216] == 78) catch @panic("test failure");
	7151	expect(v[217] == 79) catch @panic("test failure");
	7152	expect(v[218] == 80) catch @panic("test failure");
	7153	expect(v[219] == 81) catch @panic("test failure");
	7154	expect(v[220] == 82) catch @panic("test failure");
	7155	expect(v[221] == 83) catch @panic("test failure");
	7156	expect(v[222] == 84) catch @panic("test failure");
	7157	expect(v[223] == 85) catch @panic("test failure");
	7158	expect(v[224] == 86) catch @panic("test failure");
	7159	expect(v[225] == 87) catch @panic("test failure");
	7160	expect(v[226] == 88) catch @panic("test failure");
	7161	expect(v[227] == 89) catch @panic("test failure");
	7162	expect(v[228] == 90) catch @panic("test failure");
	7163	expect(v[229] == 91) catch @panic("test failure");
	7164	expect(v[230] == 92) catch @panic("test failure");
	7165	expect(v[231] == 93) catch @panic("test failure");
	7166	expect(v[232] == 94) catch @panic("test failure");
	7167	expect(v[233] == 95) catch @panic("test failure");
	7168	expect(v[234] == 96) catch @panic("test failure");
	7169	expect(v[235] == 97) catch @panic("test failure");
	7170	expect(v[236] == 98) catch @panic("test failure");
	7171	expect(v[237] == 99) catch @panic("test failure");
	7172	expect(v[238] == 0) catch @panic("test failure");
	7173	expect(v[239] == 1) catch @panic("test failure");
	7174	expect(v[240] == 2) catch @panic("test failure");
	7175	expect(v[241] == 3) catch @panic("test failure");
	7176	expect(v[242] == 4) catch @panic("test failure");
	7177	expect(v[243] == 5) catch @panic("test failure");
	7178	expect(v[244] == 6) catch @panic("test failure");
	7179	expect(v[245] == 7) catch @panic("test failure");
	7180	expect(v[246] == 8) catch @panic("test failure");
	7181	expect(v[247] == 9) catch @panic("test failure");
	7182	expect(v[248] == 10) catch @panic("test failure");
	7183	expect(v[249] == 11) catch @panic("test failure");
	7184	expect(v[250] == 12) catch @panic("test failure");
	7185	expect(v[251] == 13) catch @panic("test failure");
	7186	expect(v[252] == 14) catch @panic("test failure");
	7187	expect(v[253] == 15) catch @panic("test failure");
	7188	expect(v[254] == 16) catch @panic("test failure");
	7189	expect(v[255] == 17) catch @panic("test failure");
	7190	expect(v[256] == 18) catch @panic("test failure");
	7191	expect(v[257] == 19) catch @panic("test failure");
	7192	expect(v[258] == 20) catch @panic("test failure");
	7193	expect(v[259] == 21) catch @panic("test failure");
	7194	expect(v[260] == 22) catch @panic("test failure");
	7195	expect(v[261] == 23) catch @panic("test failure");
	7196	expect(v[262] == 24) catch @panic("test failure");
	7197	expect(v[263] == 25) catch @panic("test failure");
	7198	expect(v[264] == 26) catch @panic("test failure");
	7199	expect(v[265] == 27) catch @panic("test failure");
	7200	expect(v[266] == 28) catch @panic("test failure");
	7201	expect(v[267] == 29) catch @panic("test failure");
	7202	expect(v[268] == 30) catch @panic("test failure");
	7203	expect(v[269] == 31) catch @panic("test failure");
	7204	expect(v[270] == 32) catch @panic("test failure");
	7205	expect(v[271] == 33) catch @panic("test failure");
	7206	expect(v[272] == 34) catch @panic("test failure");
	7207	expect(v[273] == 35) catch @panic("test failure");
	7208	expect(v[274] == 36) catch @panic("test failure");
	7209	expect(v[275] == 37) catch @panic("test failure");
	7210	expect(v[276] == 38) catch @panic("test failure");
	7211	expect(v[277] == 39) catch @panic("test failure");
	7212	expect(v[278] == 40) catch @panic("test failure");
	7213	expect(v[279] == 41) catch @panic("test failure");
	7214	expect(v[280] == 42) catch @panic("test failure");
	7215	expect(v[281] == 43) catch @panic("test failure");
	7216	expect(v[282] == 44) catch @panic("test failure");
	7217	expect(v[283] == 45) catch @panic("test failure");
	7218	expect(v[284] == 46) catch @panic("test failure");
	7219	expect(v[285] == 47) catch @panic("test failure");
	7220	expect(v[286] == 48) catch @panic("test failure");
	7221	expect(v[287] == 49) catch @panic("test failure");
	7222	expect(v[288] == 50) catch @panic("test failure");
	7223	expect(v[289] == 51) catch @panic("test failure");
	7224	expect(v[290] == 52) catch @panic("test failure");
	7225	expect(v[291] == 53) catch @panic("test failure");
	7226	expect(v[292] == 54) catch @panic("test failure");
	7227	expect(v[293] == 55) catch @panic("test failure");
	7228	expect(v[294] == 56) catch @panic("test failure");
	7229	expect(v[295] == 57) catch @panic("test failure");
	7230	expect(v[296] == 58) catch @panic("test failure");
	7231	expect(v[297] == 59) catch @panic("test failure");
	7232	expect(v[298] == 60) catch @panic("test failure");
	7233	expect(v[299] == 61) catch @panic("test failure");
	7234	expect(v[300] == 62) catch @panic("test failure");
	7235	expect(v[301] == 63) catch @panic("test failure");
	7236	expect(v[302] == 64) catch @panic("test failure");
	7237	expect(v[303] == 65) catch @panic("test failure");
	7238	expect(v[304] == 66) catch @panic("test failure");
	7239	expect(v[305] == 67) catch @panic("test failure");
	7240	expect(v[306] == 68) catch @panic("test failure");
	7241	expect(v[307] == 69) catch @panic("test failure");
	7242	expect(v[308] == 70) catch @panic("test failure");
	7243	expect(v[309] == 71) catch @panic("test failure");
	7244	expect(v[310] == 72) catch @panic("test failure");
	7245	expect(v[311] == 73) catch @panic("test failure");
	7246	expect(v[312] == 74) catch @panic("test failure");
	7247	expect(v[313] == 75) catch @panic("test failure");
	7248	expect(v[314] == 76) catch @panic("test failure");
	7249	expect(v[315] == 77) catch @panic("test failure");
	7250	expect(v[316] == 78) catch @panic("test failure");
	7251	expect(v[317] == 79) catch @panic("test failure");
	7252	expect(v[318] == 80) catch @panic("test failure");
	7253	expect(v[319] == 81) catch @panic("test failure");
	7254	expect(v[320] == 82) catch @panic("test failure");
	7255	expect(v[321] == 83) catch @panic("test failure");
	7256	expect(v[322] == 84) catch @panic("test failure");
	7257	expect(v[323] == 85) catch @panic("test failure");
	7258	expect(v[324] == 86) catch @panic("test failure");
	7259	expect(v[325] == 87) catch @panic("test failure");
	7260	expect(v[326] == 88) catch @panic("test failure");
	7261	expect(v[327] == 89) catch @panic("test failure");
	7262	expect(v[328] == 90) catch @panic("test failure");
	7263	expect(v[329] == 91) catch @panic("test failure");
	7264	expect(v[330] == 92) catch @panic("test failure");
	7265	expect(v[331] == 93) catch @panic("test failure");
	7266	expect(v[332] == 94) catch @panic("test failure");
	7267	expect(v[333] == 95) catch @panic("test failure");
	7268	expect(v[334] == 96) catch @panic("test failure");
	7269	expect(v[335] == 97) catch @panic("test failure");
	7270	expect(v[336] == 98) catch @panic("test failure");
	7271	expect(v[337] == 99) catch @panic("test failure");
	7272	expect(v[338] == 0) catch @panic("test failure");
	7273	expect(v[339] == 1) catch @panic("test failure");
	7274	expect(v[340] == 2) catch @panic("test failure");
	7275	expect(v[341] == 3) catch @panic("test failure");
	7276	expect(v[342] == 4) catch @panic("test failure");
	7277	expect(v[343] == 5) catch @panic("test failure");
	7278	expect(v[344] == 6) catch @panic("test failure");
	7279	expect(v[345] == 7) catch @panic("test failure");
	7280	expect(v[346] == 8) catch @panic("test failure");
	7281	expect(v[347] == 9) catch @panic("test failure");
	7282	expect(v[348] == 10) catch @panic("test failure");
	7283	expect(v[349] == 11) catch @panic("test failure");
	7284	expect(v[350] == 12) catch @panic("test failure");
	7285	expect(v[351] == 13) catch @panic("test failure");
	7286	expect(v[352] == 14) catch @panic("test failure");
	7287	expect(v[353] == 15) catch @panic("test failure");
	7288	expect(v[354] == 16) catch @panic("test failure");
	7289	expect(v[355] == 17) catch @panic("test failure");
	7290	expect(v[356] == 18) catch @panic("test failure");
	7291	expect(v[357] == 19) catch @panic("test failure");
	7292	expect(v[358] == 20) catch @panic("test failure");
	7293	expect(v[359] == 21) catch @panic("test failure");
	7294	expect(v[360] == 22) catch @panic("test failure");
	7295	expect(v[361] == 23) catch @panic("test failure");
	7296	expect(v[362] == 24) catch @panic("test failure");
	7297	expect(v[363] == 25) catch @panic("test failure");
	7298	expect(v[364] == 26) catch @panic("test failure");
	7299	expect(v[365] == 27) catch @panic("test failure");
	7300	expect(v[366] == 28) catch @panic("test failure");
	7301	expect(v[367] == 29) catch @panic("test failure");
	7302	expect(v[368] == 30) catch @panic("test failure");
	7303	expect(v[369] == 31) catch @panic("test failure");
	7304	expect(v[370] == 32) catch @panic("test failure");
	7305	expect(v[371] == 33) catch @panic("test failure");
	7306	expect(v[372] == 34) catch @panic("test failure");
	7307	expect(v[373] == 35) catch @panic("test failure");
	7308	expect(v[374] == 36) catch @panic("test failure");
	7309	expect(v[375] == 37) catch @panic("test failure");
	7310	expect(v[376] == 38) catch @panic("test failure");
	7311	expect(v[377] == 39) catch @panic("test failure");
	7312	expect(v[378] == 40) catch @panic("test failure");
	7313	expect(v[379] == 41) catch @panic("test failure");
	7314	expect(v[380] == 42) catch @panic("test failure");
	7315	expect(v[381] == 43) catch @panic("test failure");
	7316	expect(v[382] == 44) catch @panic("test failure");
	7317	expect(v[383] == 45) catch @panic("test failure");
	7318	expect(i == 384) catch @panic("test failure");
	7319	}
	7320
	7321	extern fn c_ret_vector_384_u8() @Vector(384, u8);
	7322	extern fn c_vector_384_u8(@Vector(384, u8), usize) void;
	7323	extern fn c_test_vector_384_u8() void;
	7324
	7325	test "@Vector(384, u8)" {
	7326	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	7327	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	7328	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	7329	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	7330	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	7331
	7332	const v = c_ret_vector_384_u8();
	7333	try expect(v[0] == 46);
	7334	try expect(v[1] == 47);
	7335	try expect(v[2] == 48);
	7336	try expect(v[3] == 49);
	7337	try expect(v[4] == 50);
	7338	try expect(v[5] == 51);
	7339	try expect(v[6] == 52);
	7340	try expect(v[7] == 53);
	7341	try expect(v[8] == 54);
	7342	try expect(v[9] == 55);
	7343	try expect(v[10] == 56);
	7344	try expect(v[11] == 57);
	7345	try expect(v[12] == 58);
	7346	try expect(v[13] == 59);
	7347	try expect(v[14] == 60);
	7348	try expect(v[15] == 61);
	7349	try expect(v[16] == 62);
	7350	try expect(v[17] == 63);
	7351	try expect(v[18] == 64);
	7352	try expect(v[19] == 65);
	7353	try expect(v[20] == 66);
	7354	try expect(v[21] == 67);
	7355	try expect(v[22] == 68);
	7356	try expect(v[23] == 69);
	7357	try expect(v[24] == 70);
	7358	try expect(v[25] == 71);
	7359	try expect(v[26] == 72);
	7360	try expect(v[27] == 73);
	7361	try expect(v[28] == 74);
	7362	try expect(v[29] == 75);
	7363	try expect(v[30] == 76);
	7364	try expect(v[31] == 77);
	7365	try expect(v[32] == 78);
	7366	try expect(v[33] == 79);
	7367	try expect(v[34] == 80);
	7368	try expect(v[35] == 81);
	7369	try expect(v[36] == 82);
	7370	try expect(v[37] == 83);
	7371	try expect(v[38] == 84);
	7372	try expect(v[39] == 85);
	7373	try expect(v[40] == 86);
	7374	try expect(v[41] == 87);
	7375	try expect(v[42] == 88);
	7376	try expect(v[43] == 89);
	7377	try expect(v[44] == 90);
	7378	try expect(v[45] == 91);
	7379	try expect(v[46] == 92);
	7380	try expect(v[47] == 93);
	7381	try expect(v[48] == 94);
	7382	try expect(v[49] == 95);
	7383	try expect(v[50] == 96);
	7384	try expect(v[51] == 97);
	7385	try expect(v[52] == 98);
	7386	try expect(v[53] == 99);
	7387	try expect(v[54] == 0);
	7388	try expect(v[55] == 1);
	7389	try expect(v[56] == 2);
	7390	try expect(v[57] == 3);
	7391	try expect(v[58] == 4);
	7392	try expect(v[59] == 5);
	7393	try expect(v[60] == 6);
	7394	try expect(v[61] == 7);
	7395	try expect(v[62] == 8);
	7396	try expect(v[63] == 9);
	7397	try expect(v[64] == 10);
	7398	try expect(v[65] == 11);
	7399	try expect(v[66] == 12);
	7400	try expect(v[67] == 13);
	7401	try expect(v[68] == 14);
	7402	try expect(v[69] == 15);
	7403	try expect(v[70] == 16);
	7404	try expect(v[71] == 17);
	7405	try expect(v[72] == 18);
	7406	try expect(v[73] == 19);
	7407	try expect(v[74] == 20);
	7408	try expect(v[75] == 21);
	7409	try expect(v[76] == 22);
	7410	try expect(v[77] == 23);
	7411	try expect(v[78] == 24);
	7412	try expect(v[79] == 25);
	7413	try expect(v[80] == 26);
	7414	try expect(v[81] == 27);
	7415	try expect(v[82] == 28);
	7416	try expect(v[83] == 29);
	7417	try expect(v[84] == 30);
	7418	try expect(v[85] == 31);
	7419	try expect(v[86] == 32);
	7420	try expect(v[87] == 33);
	7421	try expect(v[88] == 34);
	7422	try expect(v[89] == 35);
	7423	try expect(v[90] == 36);
	7424	try expect(v[91] == 37);
	7425	try expect(v[92] == 38);
	7426	try expect(v[93] == 39);
	7427	try expect(v[94] == 40);
	7428	try expect(v[95] == 41);
	7429	try expect(v[96] == 42);
	7430	try expect(v[97] == 43);
	7431	try expect(v[98] == 44);
	7432	try expect(v[99] == 45);
	7433	try expect(v[100] == 46);
	7434	try expect(v[101] == 47);
	7435	try expect(v[102] == 48);
	7436	try expect(v[103] == 49);
	7437	try expect(v[104] == 50);
	7438	try expect(v[105] == 51);
	7439	try expect(v[106] == 52);
	7440	try expect(v[107] == 53);
	7441	try expect(v[108] == 54);
	7442	try expect(v[109] == 55);
	7443	try expect(v[110] == 56);
	7444	try expect(v[111] == 57);
	7445	try expect(v[112] == 58);
	7446	try expect(v[113] == 59);
	7447	try expect(v[114] == 60);
	7448	try expect(v[115] == 61);
	7449	try expect(v[116] == 62);
	7450	try expect(v[117] == 63);
	7451	try expect(v[118] == 64);
	7452	try expect(v[119] == 65);
	7453	try expect(v[120] == 66);
	7454	try expect(v[121] == 67);
	7455	try expect(v[122] == 68);
	7456	try expect(v[123] == 69);
	7457	try expect(v[124] == 70);
	7458	try expect(v[125] == 71);
	7459	try expect(v[126] == 72);
	7460	try expect(v[127] == 73);
	7461	try expect(v[128] == 74);
	7462	try expect(v[129] == 75);
	7463	try expect(v[130] == 76);
	7464	try expect(v[131] == 77);
	7465	try expect(v[132] == 78);
	7466	try expect(v[133] == 79);
	7467	try expect(v[134] == 80);
	7468	try expect(v[135] == 81);
	7469	try expect(v[136] == 82);
	7470	try expect(v[137] == 83);
	7471	try expect(v[138] == 84);
	7472	try expect(v[139] == 85);
	7473	try expect(v[140] == 86);
	7474	try expect(v[141] == 87);
	7475	try expect(v[142] == 88);
	7476	try expect(v[143] == 89);
	7477	try expect(v[144] == 90);
	7478	try expect(v[145] == 91);
	7479	try expect(v[146] == 92);
	7480	try expect(v[147] == 93);
	7481	try expect(v[148] == 94);
	7482	try expect(v[149] == 95);
	7483	try expect(v[150] == 96);
	7484	try expect(v[151] == 97);
	7485	try expect(v[152] == 98);
	7486	try expect(v[153] == 99);
	7487	try expect(v[154] == 0);
	7488	try expect(v[155] == 1);
	7489	try expect(v[156] == 2);
	7490	try expect(v[157] == 3);
	7491	try expect(v[158] == 4);
	7492	try expect(v[159] == 5);
	7493	try expect(v[160] == 6);
	7494	try expect(v[161] == 7);
	7495	try expect(v[162] == 8);
	7496	try expect(v[163] == 9);
	7497	try expect(v[164] == 10);
	7498	try expect(v[165] == 11);
	7499	try expect(v[166] == 12);
	7500	try expect(v[167] == 13);
	7501	try expect(v[168] == 14);
	7502	try expect(v[169] == 15);
	7503	try expect(v[170] == 16);
	7504	try expect(v[171] == 17);
	7505	try expect(v[172] == 18);
	7506	try expect(v[173] == 19);
	7507	try expect(v[174] == 20);
	7508	try expect(v[175] == 21);
	7509	try expect(v[176] == 22);
	7510	try expect(v[177] == 23);
	7511	try expect(v[178] == 24);
	7512	try expect(v[179] == 25);
	7513	try expect(v[180] == 26);
	7514	try expect(v[181] == 27);
	7515	try expect(v[182] == 28);
	7516	try expect(v[183] == 29);
	7517	try expect(v[184] == 30);
	7518	try expect(v[185] == 31);
	7519	try expect(v[186] == 32);
	7520	try expect(v[187] == 33);
	7521	try expect(v[188] == 34);
	7522	try expect(v[189] == 35);
	7523	try expect(v[190] == 36);
	7524	try expect(v[191] == 37);
	7525	try expect(v[192] == 38);
	7526	try expect(v[193] == 39);
	7527	try expect(v[194] == 40);
	7528	try expect(v[195] == 41);
	7529	try expect(v[196] == 42);
	7530	try expect(v[197] == 43);
	7531	try expect(v[198] == 44);
	7532	try expect(v[199] == 45);
	7533	try expect(v[200] == 46);
	7534	try expect(v[201] == 47);
	7535	try expect(v[202] == 48);
	7536	try expect(v[203] == 49);
	7537	try expect(v[204] == 50);
	7538	try expect(v[205] == 51);
	7539	try expect(v[206] == 52);
	7540	try expect(v[207] == 53);
	7541	try expect(v[208] == 54);
	7542	try expect(v[209] == 55);
	7543	try expect(v[210] == 56);
	7544	try expect(v[211] == 57);
	7545	try expect(v[212] == 58);
	7546	try expect(v[213] == 59);
	7547	try expect(v[214] == 60);
	7548	try expect(v[215] == 61);
	7549	try expect(v[216] == 62);
	7550	try expect(v[217] == 63);
	7551	try expect(v[218] == 64);
	7552	try expect(v[219] == 65);
	7553	try expect(v[220] == 66);
	7554	try expect(v[221] == 67);
	7555	try expect(v[222] == 68);
	7556	try expect(v[223] == 69);
	7557	try expect(v[224] == 70);
	7558	try expect(v[225] == 71);
	7559	try expect(v[226] == 72);
	7560	try expect(v[227] == 73);
	7561	try expect(v[228] == 74);
	7562	try expect(v[229] == 75);
	7563	try expect(v[230] == 76);
	7564	try expect(v[231] == 77);
	7565	try expect(v[232] == 78);
	7566	try expect(v[233] == 79);
	7567	try expect(v[234] == 80);
	7568	try expect(v[235] == 81);
	7569	try expect(v[236] == 82);
	7570	try expect(v[237] == 83);
	7571	try expect(v[238] == 84);
	7572	try expect(v[239] == 85);
	7573	try expect(v[240] == 86);
	7574	try expect(v[241] == 87);
	7575	try expect(v[242] == 88);
	7576	try expect(v[243] == 89);
	7577	try expect(v[244] == 90);
	7578	try expect(v[245] == 91);
	7579	try expect(v[246] == 92);
	7580	try expect(v[247] == 93);
	7581	try expect(v[248] == 94);
	7582	try expect(v[249] == 95);
	7583	try expect(v[250] == 96);
	7584	try expect(v[251] == 97);
	7585	try expect(v[252] == 98);
	7586	try expect(v[253] == 99);
	7587	try expect(v[254] == 0);
	7588	try expect(v[255] == 1);
	7589	try expect(v[256] == 2);
	7590	try expect(v[257] == 3);
	7591	try expect(v[258] == 4);
	7592	try expect(v[259] == 5);
	7593	try expect(v[260] == 6);
	7594	try expect(v[261] == 7);
	7595	try expect(v[262] == 8);
	7596	try expect(v[263] == 9);
	7597	try expect(v[264] == 10);
	7598	try expect(v[265] == 11);
	7599	try expect(v[266] == 12);
	7600	try expect(v[267] == 13);
	7601	try expect(v[268] == 14);
	7602	try expect(v[269] == 15);
	7603	try expect(v[270] == 16);
	7604	try expect(v[271] == 17);
	7605	try expect(v[272] == 18);
	7606	try expect(v[273] == 19);
	7607	try expect(v[274] == 20);
	7608	try expect(v[275] == 21);
	7609	try expect(v[276] == 22);
	7610	try expect(v[277] == 23);
	7611	try expect(v[278] == 24);
	7612	try expect(v[279] == 25);
	7613	try expect(v[280] == 26);
	7614	try expect(v[281] == 27);
	7615	try expect(v[282] == 28);
	7616	try expect(v[283] == 29);
	7617	try expect(v[284] == 30);
	7618	try expect(v[285] == 31);
	7619	try expect(v[286] == 32);
	7620	try expect(v[287] == 33);
	7621	try expect(v[288] == 34);
	7622	try expect(v[289] == 35);
	7623	try expect(v[290] == 36);
	7624	try expect(v[291] == 37);
	7625	try expect(v[292] == 38);
	7626	try expect(v[293] == 39);
	7627	try expect(v[294] == 40);
	7628	try expect(v[295] == 41);
	7629	try expect(v[296] == 42);
	7630	try expect(v[297] == 43);
	7631	try expect(v[298] == 44);
	7632	try expect(v[299] == 45);
	7633	try expect(v[300] == 46);
	7634	try expect(v[301] == 47);
	7635	try expect(v[302] == 48);
	7636	try expect(v[303] == 49);
	7637	try expect(v[304] == 50);
	7638	try expect(v[305] == 51);
	7639	try expect(v[306] == 52);
	7640	try expect(v[307] == 53);
	7641	try expect(v[308] == 54);
	7642	try expect(v[309] == 55);
	7643	try expect(v[310] == 56);
	7644	try expect(v[311] == 57);
	7645	try expect(v[312] == 58);
	7646	try expect(v[313] == 59);
	7647	try expect(v[314] == 60);
	7648	try expect(v[315] == 61);
	7649	try expect(v[316] == 62);
	7650	try expect(v[317] == 63);
	7651	try expect(v[318] == 64);
	7652	try expect(v[319] == 65);
	7653	try expect(v[320] == 66);
	7654	try expect(v[321] == 67);
	7655	try expect(v[322] == 68);
	7656	try expect(v[323] == 69);
	7657	try expect(v[324] == 70);
	7658	try expect(v[325] == 71);
	7659	try expect(v[326] == 72);
	7660	try expect(v[327] == 73);
	7661	try expect(v[328] == 74);
	7662	try expect(v[329] == 75);
	7663	try expect(v[330] == 76);
	7664	try expect(v[331] == 77);
	7665	try expect(v[332] == 78);
	7666	try expect(v[333] == 79);
	7667	try expect(v[334] == 80);
	7668	try expect(v[335] == 81);
	7669	try expect(v[336] == 82);
	7670	try expect(v[337] == 83);
	7671	try expect(v[338] == 84);
	7672	try expect(v[339] == 85);
	7673	try expect(v[340] == 86);
	7674	try expect(v[341] == 87);
	7675	try expect(v[342] == 88);
	7676	try expect(v[343] == 89);
	7677	try expect(v[344] == 90);
	7678	try expect(v[345] == 91);
	7679	try expect(v[346] == 92);
	7680	try expect(v[347] == 93);
	7681	try expect(v[348] == 94);
	7682	try expect(v[349] == 95);
	7683	try expect(v[350] == 96);
	7684	try expect(v[351] == 97);
	7685	try expect(v[352] == 98);
	7686	try expect(v[353] == 99);
	7687	try expect(v[354] == 0);
	7688	try expect(v[355] == 1);
	7689	try expect(v[356] == 2);
	7690	try expect(v[357] == 3);
	7691	try expect(v[358] == 4);
	7692	try expect(v[359] == 5);
	7693	try expect(v[360] == 6);
	7694	try expect(v[361] == 7);
	7695	try expect(v[362] == 8);
	7696	try expect(v[363] == 9);
	7697	try expect(v[364] == 10);
	7698	try expect(v[365] == 11);
	7699	try expect(v[366] == 12);
	7700	try expect(v[367] == 13);
	7701	try expect(v[368] == 14);
	7702	try expect(v[369] == 15);
	7703	try expect(v[370] == 16);
	7704	try expect(v[371] == 17);
	7705	try expect(v[372] == 18);
	7706	try expect(v[373] == 19);
	7707	try expect(v[374] == 20);
	7708	try expect(v[375] == 21);
	7709	try expect(v[376] == 22);
	7710	try expect(v[377] == 23);
	7711	try expect(v[378] == 24);
	7712	try expect(v[379] == 25);
	7713	try expect(v[380] == 26);
	7714	try expect(v[381] == 27);
	7715	try expect(v[382] == 28);
	7716	try expect(v[383] == 29);
	7717	c_vector_384_u8(.{
	7718	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	7719	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	7720	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	7721	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	7722	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	7723	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	7724	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	7725	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	7726	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	7727	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	7728	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	7729	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	7730	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	7731	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	7732	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	7733	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	7734	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	7735	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	7736	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	7737	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	7738	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	7739	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	7740	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	7741	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	7742	}, 384);
	7743	c_test_vector_384_u8();
	7744	}
	7745
	7746	export fn zig_ret_vector_512_u8() @Vector(512, u8) {
	7747	return .{
	7748	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	7749	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	7750	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	7751	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	7752	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	7753	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	7754	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	7755	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	7756	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	7757	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	7758	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	7759	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	7760	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	7761	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	7762	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	7763	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	7764	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	7765	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	7766	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	7767	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	7768	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	7769	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	7770	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	7771	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	7772	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	7773	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	7774	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	7775	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	7776	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	7777	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	7778	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	7779	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	7780	};
	7781	}
	7782	export fn zig_vector_512_u8(v: @Vector(512, u8), i: usize) void {
	7783	expect(v[0] == 26) catch @panic("test failure");
	7784	expect(v[1] == 27) catch @panic("test failure");
	7785	expect(v[2] == 28) catch @panic("test failure");
	7786	expect(v[3] == 29) catch @panic("test failure");
	7787	expect(v[4] == 30) catch @panic("test failure");
	7788	expect(v[5] == 31) catch @panic("test failure");
	7789	expect(v[6] == 32) catch @panic("test failure");
	7790	expect(v[7] == 33) catch @panic("test failure");
	7791	expect(v[8] == 34) catch @panic("test failure");
	7792	expect(v[9] == 35) catch @panic("test failure");
	7793	expect(v[10] == 36) catch @panic("test failure");
	7794	expect(v[11] == 37) catch @panic("test failure");
	7795	expect(v[12] == 38) catch @panic("test failure");
	7796	expect(v[13] == 39) catch @panic("test failure");
	7797	expect(v[14] == 40) catch @panic("test failure");
	7798	expect(v[15] == 41) catch @panic("test failure");
	7799	expect(v[16] == 42) catch @panic("test failure");
	7800	expect(v[17] == 43) catch @panic("test failure");
	7801	expect(v[18] == 44) catch @panic("test failure");
	7802	expect(v[19] == 45) catch @panic("test failure");
	7803	expect(v[20] == 46) catch @panic("test failure");
	7804	expect(v[21] == 47) catch @panic("test failure");
	7805	expect(v[22] == 48) catch @panic("test failure");
	7806	expect(v[23] == 49) catch @panic("test failure");
	7807	expect(v[24] == 50) catch @panic("test failure");
	7808	expect(v[25] == 51) catch @panic("test failure");
	7809	expect(v[26] == 52) catch @panic("test failure");
	7810	expect(v[27] == 53) catch @panic("test failure");
	7811	expect(v[28] == 54) catch @panic("test failure");
	7812	expect(v[29] == 55) catch @panic("test failure");
	7813	expect(v[30] == 56) catch @panic("test failure");
	7814	expect(v[31] == 57) catch @panic("test failure");
	7815	expect(v[32] == 58) catch @panic("test failure");
	7816	expect(v[33] == 59) catch @panic("test failure");
	7817	expect(v[34] == 60) catch @panic("test failure");
	7818	expect(v[35] == 61) catch @panic("test failure");
	7819	expect(v[36] == 62) catch @panic("test failure");
	7820	expect(v[37] == 63) catch @panic("test failure");
	7821	expect(v[38] == 64) catch @panic("test failure");
	7822	expect(v[39] == 65) catch @panic("test failure");
	7823	expect(v[40] == 66) catch @panic("test failure");
	7824	expect(v[41] == 67) catch @panic("test failure");
	7825	expect(v[42] == 68) catch @panic("test failure");
	7826	expect(v[43] == 69) catch @panic("test failure");
	7827	expect(v[44] == 70) catch @panic("test failure");
	7828	expect(v[45] == 71) catch @panic("test failure");
	7829	expect(v[46] == 72) catch @panic("test failure");
	7830	expect(v[47] == 73) catch @panic("test failure");
	7831	expect(v[48] == 74) catch @panic("test failure");
	7832	expect(v[49] == 75) catch @panic("test failure");
	7833	expect(v[50] == 76) catch @panic("test failure");
	7834	expect(v[51] == 77) catch @panic("test failure");
	7835	expect(v[52] == 78) catch @panic("test failure");
	7836	expect(v[53] == 79) catch @panic("test failure");
	7837	expect(v[54] == 80) catch @panic("test failure");
	7838	expect(v[55] == 81) catch @panic("test failure");
	7839	expect(v[56] == 82) catch @panic("test failure");
	7840	expect(v[57] == 83) catch @panic("test failure");
	7841	expect(v[58] == 84) catch @panic("test failure");
	7842	expect(v[59] == 85) catch @panic("test failure");
	7843	expect(v[60] == 86) catch @panic("test failure");
	7844	expect(v[61] == 87) catch @panic("test failure");
	7845	expect(v[62] == 88) catch @panic("test failure");
	7846	expect(v[63] == 89) catch @panic("test failure");
	7847	expect(v[64] == 90) catch @panic("test failure");
	7848	expect(v[65] == 91) catch @panic("test failure");
	7849	expect(v[66] == 92) catch @panic("test failure");
	7850	expect(v[67] == 93) catch @panic("test failure");
	7851	expect(v[68] == 94) catch @panic("test failure");
	7852	expect(v[69] == 95) catch @panic("test failure");
	7853	expect(v[70] == 96) catch @panic("test failure");
	7854	expect(v[71] == 97) catch @panic("test failure");
	7855	expect(v[72] == 98) catch @panic("test failure");
	7856	expect(v[73] == 99) catch @panic("test failure");
	7857	expect(v[74] == 0) catch @panic("test failure");
	7858	expect(v[75] == 1) catch @panic("test failure");
	7859	expect(v[76] == 2) catch @panic("test failure");
	7860	expect(v[77] == 3) catch @panic("test failure");
	7861	expect(v[78] == 4) catch @panic("test failure");
	7862	expect(v[79] == 5) catch @panic("test failure");
	7863	expect(v[80] == 6) catch @panic("test failure");
	7864	expect(v[81] == 7) catch @panic("test failure");
	7865	expect(v[82] == 8) catch @panic("test failure");
	7866	expect(v[83] == 9) catch @panic("test failure");
	7867	expect(v[84] == 10) catch @panic("test failure");
	7868	expect(v[85] == 11) catch @panic("test failure");
	7869	expect(v[86] == 12) catch @panic("test failure");
	7870	expect(v[87] == 13) catch @panic("test failure");
	7871	expect(v[88] == 14) catch @panic("test failure");
	7872	expect(v[89] == 15) catch @panic("test failure");
	7873	expect(v[90] == 16) catch @panic("test failure");
	7874	expect(v[91] == 17) catch @panic("test failure");
	7875	expect(v[92] == 18) catch @panic("test failure");
	7876	expect(v[93] == 19) catch @panic("test failure");
	7877	expect(v[94] == 20) catch @panic("test failure");
	7878	expect(v[95] == 21) catch @panic("test failure");
	7879	expect(v[96] == 22) catch @panic("test failure");
	7880	expect(v[97] == 23) catch @panic("test failure");
	7881	expect(v[98] == 24) catch @panic("test failure");
	7882	expect(v[99] == 25) catch @panic("test failure");
	7883	expect(v[100] == 26) catch @panic("test failure");
	7884	expect(v[101] == 27) catch @panic("test failure");
	7885	expect(v[102] == 28) catch @panic("test failure");
	7886	expect(v[103] == 29) catch @panic("test failure");
	7887	expect(v[104] == 30) catch @panic("test failure");
	7888	expect(v[105] == 31) catch @panic("test failure");
	7889	expect(v[106] == 32) catch @panic("test failure");
	7890	expect(v[107] == 33) catch @panic("test failure");
	7891	expect(v[108] == 34) catch @panic("test failure");
	7892	expect(v[109] == 35) catch @panic("test failure");
	7893	expect(v[110] == 36) catch @panic("test failure");
	7894	expect(v[111] == 37) catch @panic("test failure");
	7895	expect(v[112] == 38) catch @panic("test failure");
	7896	expect(v[113] == 39) catch @panic("test failure");
	7897	expect(v[114] == 40) catch @panic("test failure");
	7898	expect(v[115] == 41) catch @panic("test failure");
	7899	expect(v[116] == 42) catch @panic("test failure");
	7900	expect(v[117] == 43) catch @panic("test failure");
	7901	expect(v[118] == 44) catch @panic("test failure");
	7902	expect(v[119] == 45) catch @panic("test failure");
	7903	expect(v[120] == 46) catch @panic("test failure");
	7904	expect(v[121] == 47) catch @panic("test failure");
	7905	expect(v[122] == 48) catch @panic("test failure");
	7906	expect(v[123] == 49) catch @panic("test failure");
	7907	expect(v[124] == 50) catch @panic("test failure");
	7908	expect(v[125] == 51) catch @panic("test failure");
	7909	expect(v[126] == 52) catch @panic("test failure");
	7910	expect(v[127] == 53) catch @panic("test failure");
	7911	expect(v[128] == 54) catch @panic("test failure");
	7912	expect(v[129] == 55) catch @panic("test failure");
	7913	expect(v[130] == 56) catch @panic("test failure");
	7914	expect(v[131] == 57) catch @panic("test failure");
	7915	expect(v[132] == 58) catch @panic("test failure");
	7916	expect(v[133] == 59) catch @panic("test failure");
	7917	expect(v[134] == 60) catch @panic("test failure");
	7918	expect(v[135] == 61) catch @panic("test failure");
	7919	expect(v[136] == 62) catch @panic("test failure");
	7920	expect(v[137] == 63) catch @panic("test failure");
	7921	expect(v[138] == 64) catch @panic("test failure");
	7922	expect(v[139] == 65) catch @panic("test failure");
	7923	expect(v[140] == 66) catch @panic("test failure");
	7924	expect(v[141] == 67) catch @panic("test failure");
	7925	expect(v[142] == 68) catch @panic("test failure");
	7926	expect(v[143] == 69) catch @panic("test failure");
	7927	expect(v[144] == 70) catch @panic("test failure");
	7928	expect(v[145] == 71) catch @panic("test failure");
	7929	expect(v[146] == 72) catch @panic("test failure");
	7930	expect(v[147] == 73) catch @panic("test failure");
	7931	expect(v[148] == 74) catch @panic("test failure");
	7932	expect(v[149] == 75) catch @panic("test failure");
	7933	expect(v[150] == 76) catch @panic("test failure");
	7934	expect(v[151] == 77) catch @panic("test failure");
	7935	expect(v[152] == 78) catch @panic("test failure");
	7936	expect(v[153] == 79) catch @panic("test failure");
	7937	expect(v[154] == 80) catch @panic("test failure");
	7938	expect(v[155] == 81) catch @panic("test failure");
	7939	expect(v[156] == 82) catch @panic("test failure");
	7940	expect(v[157] == 83) catch @panic("test failure");
	7941	expect(v[158] == 84) catch @panic("test failure");
	7942	expect(v[159] == 85) catch @panic("test failure");
	7943	expect(v[160] == 86) catch @panic("test failure");
	7944	expect(v[161] == 87) catch @panic("test failure");
	7945	expect(v[162] == 88) catch @panic("test failure");
	7946	expect(v[163] == 89) catch @panic("test failure");
	7947	expect(v[164] == 90) catch @panic("test failure");
	7948	expect(v[165] == 91) catch @panic("test failure");
	7949	expect(v[166] == 92) catch @panic("test failure");
	7950	expect(v[167] == 93) catch @panic("test failure");
	7951	expect(v[168] == 94) catch @panic("test failure");
	7952	expect(v[169] == 95) catch @panic("test failure");
	7953	expect(v[170] == 96) catch @panic("test failure");
	7954	expect(v[171] == 97) catch @panic("test failure");
	7955	expect(v[172] == 98) catch @panic("test failure");
	7956	expect(v[173] == 99) catch @panic("test failure");
	7957	expect(v[174] == 0) catch @panic("test failure");
	7958	expect(v[175] == 1) catch @panic("test failure");
	7959	expect(v[176] == 2) catch @panic("test failure");
	7960	expect(v[177] == 3) catch @panic("test failure");
	7961	expect(v[178] == 4) catch @panic("test failure");
	7962	expect(v[179] == 5) catch @panic("test failure");
	7963	expect(v[180] == 6) catch @panic("test failure");
	7964	expect(v[181] == 7) catch @panic("test failure");
	7965	expect(v[182] == 8) catch @panic("test failure");
	7966	expect(v[183] == 9) catch @panic("test failure");
	7967	expect(v[184] == 10) catch @panic("test failure");
	7968	expect(v[185] == 11) catch @panic("test failure");
	7969	expect(v[186] == 12) catch @panic("test failure");
	7970	expect(v[187] == 13) catch @panic("test failure");
	7971	expect(v[188] == 14) catch @panic("test failure");
	7972	expect(v[189] == 15) catch @panic("test failure");
	7973	expect(v[190] == 16) catch @panic("test failure");
	7974	expect(v[191] == 17) catch @panic("test failure");
	7975	expect(v[192] == 18) catch @panic("test failure");
	7976	expect(v[193] == 19) catch @panic("test failure");
	7977	expect(v[194] == 20) catch @panic("test failure");
	7978	expect(v[195] == 21) catch @panic("test failure");
	7979	expect(v[196] == 22) catch @panic("test failure");
	7980	expect(v[197] == 23) catch @panic("test failure");
	7981	expect(v[198] == 24) catch @panic("test failure");
	7982	expect(v[199] == 25) catch @panic("test failure");
	7983	expect(v[200] == 26) catch @panic("test failure");
	7984	expect(v[201] == 27) catch @panic("test failure");
	7985	expect(v[202] == 28) catch @panic("test failure");
	7986	expect(v[203] == 29) catch @panic("test failure");
	7987	expect(v[204] == 30) catch @panic("test failure");
	7988	expect(v[205] == 31) catch @panic("test failure");
	7989	expect(v[206] == 32) catch @panic("test failure");
	7990	expect(v[207] == 33) catch @panic("test failure");
	7991	expect(v[208] == 34) catch @panic("test failure");
	7992	expect(v[209] == 35) catch @panic("test failure");
	7993	expect(v[210] == 36) catch @panic("test failure");
	7994	expect(v[211] == 37) catch @panic("test failure");
	7995	expect(v[212] == 38) catch @panic("test failure");
	7996	expect(v[213] == 39) catch @panic("test failure");
	7997	expect(v[214] == 40) catch @panic("test failure");
	7998	expect(v[215] == 41) catch @panic("test failure");
	7999	expect(v[216] == 42) catch @panic("test failure");
	8000	expect(v[217] == 43) catch @panic("test failure");
	8001	expect(v[218] == 44) catch @panic("test failure");
	8002	expect(v[219] == 45) catch @panic("test failure");
	8003	expect(v[220] == 46) catch @panic("test failure");
	8004	expect(v[221] == 47) catch @panic("test failure");
	8005	expect(v[222] == 48) catch @panic("test failure");
	8006	expect(v[223] == 49) catch @panic("test failure");
	8007	expect(v[224] == 50) catch @panic("test failure");
	8008	expect(v[225] == 51) catch @panic("test failure");
	8009	expect(v[226] == 52) catch @panic("test failure");
	8010	expect(v[227] == 53) catch @panic("test failure");
	8011	expect(v[228] == 54) catch @panic("test failure");
	8012	expect(v[229] == 55) catch @panic("test failure");
	8013	expect(v[230] == 56) catch @panic("test failure");
	8014	expect(v[231] == 57) catch @panic("test failure");
	8015	expect(v[232] == 58) catch @panic("test failure");
	8016	expect(v[233] == 59) catch @panic("test failure");
	8017	expect(v[234] == 60) catch @panic("test failure");
	8018	expect(v[235] == 61) catch @panic("test failure");
	8019	expect(v[236] == 62) catch @panic("test failure");
	8020	expect(v[237] == 63) catch @panic("test failure");
	8021	expect(v[238] == 64) catch @panic("test failure");
	8022	expect(v[239] == 65) catch @panic("test failure");
	8023	expect(v[240] == 66) catch @panic("test failure");
	8024	expect(v[241] == 67) catch @panic("test failure");
	8025	expect(v[242] == 68) catch @panic("test failure");
	8026	expect(v[243] == 69) catch @panic("test failure");
	8027	expect(v[244] == 70) catch @panic("test failure");
	8028	expect(v[245] == 71) catch @panic("test failure");
	8029	expect(v[246] == 72) catch @panic("test failure");
	8030	expect(v[247] == 73) catch @panic("test failure");
	8031	expect(v[248] == 74) catch @panic("test failure");
	8032	expect(v[249] == 75) catch @panic("test failure");
	8033	expect(v[250] == 76) catch @panic("test failure");
	8034	expect(v[251] == 77) catch @panic("test failure");
	8035	expect(v[252] == 78) catch @panic("test failure");
	8036	expect(v[253] == 79) catch @panic("test failure");
	8037	expect(v[254] == 80) catch @panic("test failure");
	8038	expect(v[255] == 81) catch @panic("test failure");
	8039	expect(v[256] == 82) catch @panic("test failure");
	8040	expect(v[257] == 83) catch @panic("test failure");
	8041	expect(v[258] == 84) catch @panic("test failure");
	8042	expect(v[259] == 85) catch @panic("test failure");
	8043	expect(v[260] == 86) catch @panic("test failure");
	8044	expect(v[261] == 87) catch @panic("test failure");
	8045	expect(v[262] == 88) catch @panic("test failure");
	8046	expect(v[263] == 89) catch @panic("test failure");
	8047	expect(v[264] == 90) catch @panic("test failure");
	8048	expect(v[265] == 91) catch @panic("test failure");
	8049	expect(v[266] == 92) catch @panic("test failure");
	8050	expect(v[267] == 93) catch @panic("test failure");
	8051	expect(v[268] == 94) catch @panic("test failure");
	8052	expect(v[269] == 95) catch @panic("test failure");
	8053	expect(v[270] == 96) catch @panic("test failure");
	8054	expect(v[271] == 97) catch @panic("test failure");
	8055	expect(v[272] == 98) catch @panic("test failure");
	8056	expect(v[273] == 99) catch @panic("test failure");
	8057	expect(v[274] == 0) catch @panic("test failure");
	8058	expect(v[275] == 1) catch @panic("test failure");
	8059	expect(v[276] == 2) catch @panic("test failure");
	8060	expect(v[277] == 3) catch @panic("test failure");
	8061	expect(v[278] == 4) catch @panic("test failure");
	8062	expect(v[279] == 5) catch @panic("test failure");
	8063	expect(v[280] == 6) catch @panic("test failure");
	8064	expect(v[281] == 7) catch @panic("test failure");
	8065	expect(v[282] == 8) catch @panic("test failure");
	8066	expect(v[283] == 9) catch @panic("test failure");
	8067	expect(v[284] == 10) catch @panic("test failure");
	8068	expect(v[285] == 11) catch @panic("test failure");
	8069	expect(v[286] == 12) catch @panic("test failure");
	8070	expect(v[287] == 13) catch @panic("test failure");
	8071	expect(v[288] == 14) catch @panic("test failure");
	8072	expect(v[289] == 15) catch @panic("test failure");
	8073	expect(v[290] == 16) catch @panic("test failure");
	8074	expect(v[291] == 17) catch @panic("test failure");
	8075	expect(v[292] == 18) catch @panic("test failure");
	8076	expect(v[293] == 19) catch @panic("test failure");
	8077	expect(v[294] == 20) catch @panic("test failure");
	8078	expect(v[295] == 21) catch @panic("test failure");
	8079	expect(v[296] == 22) catch @panic("test failure");
	8080	expect(v[297] == 23) catch @panic("test failure");
	8081	expect(v[298] == 24) catch @panic("test failure");
	8082	expect(v[299] == 25) catch @panic("test failure");
	8083	expect(v[300] == 26) catch @panic("test failure");
	8084	expect(v[301] == 27) catch @panic("test failure");
	8085	expect(v[302] == 28) catch @panic("test failure");
	8086	expect(v[303] == 29) catch @panic("test failure");
	8087	expect(v[304] == 30) catch @panic("test failure");
	8088	expect(v[305] == 31) catch @panic("test failure");
	8089	expect(v[306] == 32) catch @panic("test failure");
	8090	expect(v[307] == 33) catch @panic("test failure");
	8091	expect(v[308] == 34) catch @panic("test failure");
	8092	expect(v[309] == 35) catch @panic("test failure");
	8093	expect(v[310] == 36) catch @panic("test failure");
	8094	expect(v[311] == 37) catch @panic("test failure");
	8095	expect(v[312] == 38) catch @panic("test failure");
	8096	expect(v[313] == 39) catch @panic("test failure");
	8097	expect(v[314] == 40) catch @panic("test failure");
	8098	expect(v[315] == 41) catch @panic("test failure");
	8099	expect(v[316] == 42) catch @panic("test failure");
	8100	expect(v[317] == 43) catch @panic("test failure");
	8101	expect(v[318] == 44) catch @panic("test failure");
	8102	expect(v[319] == 45) catch @panic("test failure");
	8103	expect(v[320] == 46) catch @panic("test failure");
	8104	expect(v[321] == 47) catch @panic("test failure");
	8105	expect(v[322] == 48) catch @panic("test failure");
	8106	expect(v[323] == 49) catch @panic("test failure");
	8107	expect(v[324] == 50) catch @panic("test failure");
	8108	expect(v[325] == 51) catch @panic("test failure");
	8109	expect(v[326] == 52) catch @panic("test failure");
	8110	expect(v[327] == 53) catch @panic("test failure");
	8111	expect(v[328] == 54) catch @panic("test failure");
	8112	expect(v[329] == 55) catch @panic("test failure");
	8113	expect(v[330] == 56) catch @panic("test failure");
	8114	expect(v[331] == 57) catch @panic("test failure");
	8115	expect(v[332] == 58) catch @panic("test failure");
	8116	expect(v[333] == 59) catch @panic("test failure");
	8117	expect(v[334] == 60) catch @panic("test failure");
	8118	expect(v[335] == 61) catch @panic("test failure");
	8119	expect(v[336] == 62) catch @panic("test failure");
	8120	expect(v[337] == 63) catch @panic("test failure");
	8121	expect(v[338] == 64) catch @panic("test failure");
	8122	expect(v[339] == 65) catch @panic("test failure");
	8123	expect(v[340] == 66) catch @panic("test failure");
	8124	expect(v[341] == 67) catch @panic("test failure");
	8125	expect(v[342] == 68) catch @panic("test failure");
	8126	expect(v[343] == 69) catch @panic("test failure");
	8127	expect(v[344] == 70) catch @panic("test failure");
	8128	expect(v[345] == 71) catch @panic("test failure");
	8129	expect(v[346] == 72) catch @panic("test failure");
	8130	expect(v[347] == 73) catch @panic("test failure");
	8131	expect(v[348] == 74) catch @panic("test failure");
	8132	expect(v[349] == 75) catch @panic("test failure");
	8133	expect(v[350] == 76) catch @panic("test failure");
	8134	expect(v[351] == 77) catch @panic("test failure");
	8135	expect(v[352] == 78) catch @panic("test failure");
	8136	expect(v[353] == 79) catch @panic("test failure");
	8137	expect(v[354] == 80) catch @panic("test failure");
	8138	expect(v[355] == 81) catch @panic("test failure");
	8139	expect(v[356] == 82) catch @panic("test failure");
	8140	expect(v[357] == 83) catch @panic("test failure");
	8141	expect(v[358] == 84) catch @panic("test failure");
	8142	expect(v[359] == 85) catch @panic("test failure");
	8143	expect(v[360] == 86) catch @panic("test failure");
	8144	expect(v[361] == 87) catch @panic("test failure");
	8145	expect(v[362] == 88) catch @panic("test failure");
	8146	expect(v[363] == 89) catch @panic("test failure");
	8147	expect(v[364] == 90) catch @panic("test failure");
	8148	expect(v[365] == 91) catch @panic("test failure");
	8149	expect(v[366] == 92) catch @panic("test failure");
	8150	expect(v[367] == 93) catch @panic("test failure");
	8151	expect(v[368] == 94) catch @panic("test failure");
	8152	expect(v[369] == 95) catch @panic("test failure");
	8153	expect(v[370] == 96) catch @panic("test failure");
	8154	expect(v[371] == 97) catch @panic("test failure");
	8155	expect(v[372] == 98) catch @panic("test failure");
	8156	expect(v[373] == 99) catch @panic("test failure");
	8157	expect(v[374] == 0) catch @panic("test failure");
	8158	expect(v[375] == 1) catch @panic("test failure");
	8159	expect(v[376] == 2) catch @panic("test failure");
	8160	expect(v[377] == 3) catch @panic("test failure");
	8161	expect(v[378] == 4) catch @panic("test failure");
	8162	expect(v[379] == 5) catch @panic("test failure");
	8163	expect(v[380] == 6) catch @panic("test failure");
	8164	expect(v[381] == 7) catch @panic("test failure");
	8165	expect(v[382] == 8) catch @panic("test failure");
	8166	expect(v[383] == 9) catch @panic("test failure");
	8167	expect(v[384] == 10) catch @panic("test failure");
	8168	expect(v[385] == 11) catch @panic("test failure");
	8169	expect(v[386] == 12) catch @panic("test failure");
	8170	expect(v[387] == 13) catch @panic("test failure");
	8171	expect(v[388] == 14) catch @panic("test failure");
	8172	expect(v[389] == 15) catch @panic("test failure");
	8173	expect(v[390] == 16) catch @panic("test failure");
	8174	expect(v[391] == 17) catch @panic("test failure");
	8175	expect(v[392] == 18) catch @panic("test failure");
	8176	expect(v[393] == 19) catch @panic("test failure");
	8177	expect(v[394] == 20) catch @panic("test failure");
	8178	expect(v[395] == 21) catch @panic("test failure");
	8179	expect(v[396] == 22) catch @panic("test failure");
	8180	expect(v[397] == 23) catch @panic("test failure");
	8181	expect(v[398] == 24) catch @panic("test failure");
	8182	expect(v[399] == 25) catch @panic("test failure");
	8183	expect(v[400] == 26) catch @panic("test failure");
	8184	expect(v[401] == 27) catch @panic("test failure");
	8185	expect(v[402] == 28) catch @panic("test failure");
	8186	expect(v[403] == 29) catch @panic("test failure");
	8187	expect(v[404] == 30) catch @panic("test failure");
	8188	expect(v[405] == 31) catch @panic("test failure");
	8189	expect(v[406] == 32) catch @panic("test failure");
	8190	expect(v[407] == 33) catch @panic("test failure");
	8191	expect(v[408] == 34) catch @panic("test failure");
	8192	expect(v[409] == 35) catch @panic("test failure");
	8193	expect(v[410] == 36) catch @panic("test failure");
	8194	expect(v[411] == 37) catch @panic("test failure");
	8195	expect(v[412] == 38) catch @panic("test failure");
	8196	expect(v[413] == 39) catch @panic("test failure");
	8197	expect(v[414] == 40) catch @panic("test failure");
	8198	expect(v[415] == 41) catch @panic("test failure");
	8199	expect(v[416] == 42) catch @panic("test failure");
	8200	expect(v[417] == 43) catch @panic("test failure");
	8201	expect(v[418] == 44) catch @panic("test failure");
	8202	expect(v[419] == 45) catch @panic("test failure");
	8203	expect(v[420] == 46) catch @panic("test failure");
	8204	expect(v[421] == 47) catch @panic("test failure");
	8205	expect(v[422] == 48) catch @panic("test failure");
	8206	expect(v[423] == 49) catch @panic("test failure");
	8207	expect(v[424] == 50) catch @panic("test failure");
	8208	expect(v[425] == 51) catch @panic("test failure");
	8209	expect(v[426] == 52) catch @panic("test failure");
	8210	expect(v[427] == 53) catch @panic("test failure");
	8211	expect(v[428] == 54) catch @panic("test failure");
	8212	expect(v[429] == 55) catch @panic("test failure");
	8213	expect(v[430] == 56) catch @panic("test failure");
	8214	expect(v[431] == 57) catch @panic("test failure");
	8215	expect(v[432] == 58) catch @panic("test failure");
	8216	expect(v[433] == 59) catch @panic("test failure");
	8217	expect(v[434] == 60) catch @panic("test failure");
	8218	expect(v[435] == 61) catch @panic("test failure");
	8219	expect(v[436] == 62) catch @panic("test failure");
	8220	expect(v[437] == 63) catch @panic("test failure");
	8221	expect(v[438] == 64) catch @panic("test failure");
	8222	expect(v[439] == 65) catch @panic("test failure");
	8223	expect(v[440] == 66) catch @panic("test failure");
	8224	expect(v[441] == 67) catch @panic("test failure");
	8225	expect(v[442] == 68) catch @panic("test failure");
	8226	expect(v[443] == 69) catch @panic("test failure");
	8227	expect(v[444] == 70) catch @panic("test failure");
	8228	expect(v[445] == 71) catch @panic("test failure");
	8229	expect(v[446] == 72) catch @panic("test failure");
	8230	expect(v[447] == 73) catch @panic("test failure");
	8231	expect(v[448] == 74) catch @panic("test failure");
	8232	expect(v[449] == 75) catch @panic("test failure");
	8233	expect(v[450] == 76) catch @panic("test failure");
	8234	expect(v[451] == 77) catch @panic("test failure");
	8235	expect(v[452] == 78) catch @panic("test failure");
	8236	expect(v[453] == 79) catch @panic("test failure");
	8237	expect(v[454] == 80) catch @panic("test failure");
	8238	expect(v[455] == 81) catch @panic("test failure");
	8239	expect(v[456] == 82) catch @panic("test failure");
	8240	expect(v[457] == 83) catch @panic("test failure");
	8241	expect(v[458] == 84) catch @panic("test failure");
	8242	expect(v[459] == 85) catch @panic("test failure");
	8243	expect(v[460] == 86) catch @panic("test failure");
	8244	expect(v[461] == 87) catch @panic("test failure");
	8245	expect(v[462] == 88) catch @panic("test failure");
	8246	expect(v[463] == 89) catch @panic("test failure");
	8247	expect(v[464] == 90) catch @panic("test failure");
	8248	expect(v[465] == 91) catch @panic("test failure");
	8249	expect(v[466] == 92) catch @panic("test failure");
	8250	expect(v[467] == 93) catch @panic("test failure");
	8251	expect(v[468] == 94) catch @panic("test failure");
	8252	expect(v[469] == 95) catch @panic("test failure");
	8253	expect(v[470] == 96) catch @panic("test failure");
	8254	expect(v[471] == 97) catch @panic("test failure");
	8255	expect(v[472] == 98) catch @panic("test failure");
	8256	expect(v[473] == 99) catch @panic("test failure");
	8257	expect(v[474] == 0) catch @panic("test failure");
	8258	expect(v[475] == 1) catch @panic("test failure");
	8259	expect(v[476] == 2) catch @panic("test failure");
	8260	expect(v[477] == 3) catch @panic("test failure");
	8261	expect(v[478] == 4) catch @panic("test failure");
	8262	expect(v[479] == 5) catch @panic("test failure");
	8263	expect(v[480] == 6) catch @panic("test failure");
	8264	expect(v[481] == 7) catch @panic("test failure");
	8265	expect(v[482] == 8) catch @panic("test failure");
	8266	expect(v[483] == 9) catch @panic("test failure");
	8267	expect(v[484] == 10) catch @panic("test failure");
	8268	expect(v[485] == 11) catch @panic("test failure");
	8269	expect(v[486] == 12) catch @panic("test failure");
	8270	expect(v[487] == 13) catch @panic("test failure");
	8271	expect(v[488] == 14) catch @panic("test failure");
	8272	expect(v[489] == 15) catch @panic("test failure");
	8273	expect(v[490] == 16) catch @panic("test failure");
	8274	expect(v[491] == 17) catch @panic("test failure");
	8275	expect(v[492] == 18) catch @panic("test failure");
	8276	expect(v[493] == 19) catch @panic("test failure");
	8277	expect(v[494] == 20) catch @panic("test failure");
	8278	expect(v[495] == 21) catch @panic("test failure");
	8279	expect(v[496] == 22) catch @panic("test failure");
	8280	expect(v[497] == 23) catch @panic("test failure");
	8281	expect(v[498] == 24) catch @panic("test failure");
	8282	expect(v[499] == 25) catch @panic("test failure");
	8283	expect(v[500] == 26) catch @panic("test failure");
	8284	expect(v[501] == 27) catch @panic("test failure");
	8285	expect(v[502] == 28) catch @panic("test failure");
	8286	expect(v[503] == 29) catch @panic("test failure");
	8287	expect(v[504] == 30) catch @panic("test failure");
	8288	expect(v[505] == 31) catch @panic("test failure");
	8289	expect(v[506] == 32) catch @panic("test failure");
	8290	expect(v[507] == 33) catch @panic("test failure");
	8291	expect(v[508] == 34) catch @panic("test failure");
	8292	expect(v[509] == 35) catch @panic("test failure");
	8293	expect(v[510] == 36) catch @panic("test failure");
	8294	expect(v[511] == 37) catch @panic("test failure");
	8295	expect(i == 512) catch @panic("test failure");
	8296	}
	8297
	8298	extern fn c_ret_vector_512_u8() @Vector(512, u8);
	8299	extern fn c_vector_512_u8(@Vector(512, u8), usize) void;
	8300	extern fn c_test_vector_512_u8() void;
	8301
	8302	test "@Vector(512, u8)" {
	8303	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	8304	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	8305	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	8306	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	8307	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	8308
	8309	const v = c_ret_vector_512_u8();
	8310	try expect(v[0] == 38);
	8311	try expect(v[1] == 39);
	8312	try expect(v[2] == 40);
	8313	try expect(v[3] == 41);
	8314	try expect(v[4] == 42);
	8315	try expect(v[5] == 43);
	8316	try expect(v[6] == 44);
	8317	try expect(v[7] == 45);
	8318	try expect(v[8] == 46);
	8319	try expect(v[9] == 47);
	8320	try expect(v[10] == 48);
	8321	try expect(v[11] == 49);
	8322	try expect(v[12] == 50);
	8323	try expect(v[13] == 51);
	8324	try expect(v[14] == 52);
	8325	try expect(v[15] == 53);
	8326	try expect(v[16] == 54);
	8327	try expect(v[17] == 55);
	8328	try expect(v[18] == 56);
	8329	try expect(v[19] == 57);
	8330	try expect(v[20] == 58);
	8331	try expect(v[21] == 59);
	8332	try expect(v[22] == 60);
	8333	try expect(v[23] == 61);
	8334	try expect(v[24] == 62);
	8335	try expect(v[25] == 63);
	8336	try expect(v[26] == 64);
	8337	try expect(v[27] == 65);
	8338	try expect(v[28] == 66);
	8339	try expect(v[29] == 67);
	8340	try expect(v[30] == 68);
	8341	try expect(v[31] == 69);
	8342	try expect(v[32] == 70);
	8343	try expect(v[33] == 71);
	8344	try expect(v[34] == 72);
	8345	try expect(v[35] == 73);
	8346	try expect(v[36] == 74);
	8347	try expect(v[37] == 75);
	8348	try expect(v[38] == 76);
	8349	try expect(v[39] == 77);
	8350	try expect(v[40] == 78);
	8351	try expect(v[41] == 79);
	8352	try expect(v[42] == 80);
	8353	try expect(v[43] == 81);
	8354	try expect(v[44] == 82);
	8355	try expect(v[45] == 83);
	8356	try expect(v[46] == 84);
	8357	try expect(v[47] == 85);
	8358	try expect(v[48] == 86);
	8359	try expect(v[49] == 87);
	8360	try expect(v[50] == 88);
	8361	try expect(v[51] == 89);
	8362	try expect(v[52] == 90);
	8363	try expect(v[53] == 91);
	8364	try expect(v[54] == 92);
	8365	try expect(v[55] == 93);
	8366	try expect(v[56] == 94);
	8367	try expect(v[57] == 95);
	8368	try expect(v[58] == 96);
	8369	try expect(v[59] == 97);
	8370	try expect(v[60] == 98);
	8371	try expect(v[61] == 99);
	8372	try expect(v[62] == 0);
	8373	try expect(v[63] == 1);
	8374	try expect(v[64] == 2);
	8375	try expect(v[65] == 3);
	8376	try expect(v[66] == 4);
	8377	try expect(v[67] == 5);
	8378	try expect(v[68] == 6);
	8379	try expect(v[69] == 7);
	8380	try expect(v[70] == 8);
	8381	try expect(v[71] == 9);
	8382	try expect(v[72] == 10);
	8383	try expect(v[73] == 11);
	8384	try expect(v[74] == 12);
	8385	try expect(v[75] == 13);
	8386	try expect(v[76] == 14);
	8387	try expect(v[77] == 15);
	8388	try expect(v[78] == 16);
	8389	try expect(v[79] == 17);
	8390	try expect(v[80] == 18);
	8391	try expect(v[81] == 19);
	8392	try expect(v[82] == 20);
	8393	try expect(v[83] == 21);
	8394	try expect(v[84] == 22);
	8395	try expect(v[85] == 23);
	8396	try expect(v[86] == 24);
	8397	try expect(v[87] == 25);
	8398	try expect(v[88] == 26);
	8399	try expect(v[89] == 27);
	8400	try expect(v[90] == 28);
	8401	try expect(v[91] == 29);
	8402	try expect(v[92] == 30);
	8403	try expect(v[93] == 31);
	8404	try expect(v[94] == 32);
	8405	try expect(v[95] == 33);
	8406	try expect(v[96] == 34);
	8407	try expect(v[97] == 35);
	8408	try expect(v[98] == 36);
	8409	try expect(v[99] == 37);
	8410	try expect(v[100] == 38);
	8411	try expect(v[101] == 39);
	8412	try expect(v[102] == 40);
	8413	try expect(v[103] == 41);
	8414	try expect(v[104] == 42);
	8415	try expect(v[105] == 43);
	8416	try expect(v[106] == 44);
	8417	try expect(v[107] == 45);
	8418	try expect(v[108] == 46);
	8419	try expect(v[109] == 47);
	8420	try expect(v[110] == 48);
	8421	try expect(v[111] == 49);
	8422	try expect(v[112] == 50);
	8423	try expect(v[113] == 51);
	8424	try expect(v[114] == 52);
	8425	try expect(v[115] == 53);
	8426	try expect(v[116] == 54);
	8427	try expect(v[117] == 55);
	8428	try expect(v[118] == 56);
	8429	try expect(v[119] == 57);
	8430	try expect(v[120] == 58);
	8431	try expect(v[121] == 59);
	8432	try expect(v[122] == 60);
	8433	try expect(v[123] == 61);
	8434	try expect(v[124] == 62);
	8435	try expect(v[125] == 63);
	8436	try expect(v[126] == 64);
	8437	try expect(v[127] == 65);
	8438	try expect(v[128] == 66);
	8439	try expect(v[129] == 67);
	8440	try expect(v[130] == 68);
	8441	try expect(v[131] == 69);
	8442	try expect(v[132] == 70);
	8443	try expect(v[133] == 71);
	8444	try expect(v[134] == 72);
	8445	try expect(v[135] == 73);
	8446	try expect(v[136] == 74);
	8447	try expect(v[137] == 75);
	8448	try expect(v[138] == 76);
	8449	try expect(v[139] == 77);
	8450	try expect(v[140] == 78);
	8451	try expect(v[141] == 79);
	8452	try expect(v[142] == 80);
	8453	try expect(v[143] == 81);
	8454	try expect(v[144] == 82);
	8455	try expect(v[145] == 83);
	8456	try expect(v[146] == 84);
	8457	try expect(v[147] == 85);
	8458	try expect(v[148] == 86);
	8459	try expect(v[149] == 87);
	8460	try expect(v[150] == 88);
	8461	try expect(v[151] == 89);
	8462	try expect(v[152] == 90);
	8463	try expect(v[153] == 91);
	8464	try expect(v[154] == 92);
	8465	try expect(v[155] == 93);
	8466	try expect(v[156] == 94);
	8467	try expect(v[157] == 95);
	8468	try expect(v[158] == 96);
	8469	try expect(v[159] == 97);
	8470	try expect(v[160] == 98);
	8471	try expect(v[161] == 99);
	8472	try expect(v[162] == 0);
	8473	try expect(v[163] == 1);
	8474	try expect(v[164] == 2);
	8475	try expect(v[165] == 3);
	8476	try expect(v[166] == 4);
	8477	try expect(v[167] == 5);
	8478	try expect(v[168] == 6);
	8479	try expect(v[169] == 7);
	8480	try expect(v[170] == 8);
	8481	try expect(v[171] == 9);
	8482	try expect(v[172] == 10);
	8483	try expect(v[173] == 11);
	8484	try expect(v[174] == 12);
	8485	try expect(v[175] == 13);
	8486	try expect(v[176] == 14);
	8487	try expect(v[177] == 15);
	8488	try expect(v[178] == 16);
	8489	try expect(v[179] == 17);
	8490	try expect(v[180] == 18);
	8491	try expect(v[181] == 19);
	8492	try expect(v[182] == 20);
	8493	try expect(v[183] == 21);
	8494	try expect(v[184] == 22);
	8495	try expect(v[185] == 23);
	8496	try expect(v[186] == 24);
	8497	try expect(v[187] == 25);
	8498	try expect(v[188] == 26);
	8499	try expect(v[189] == 27);
	8500	try expect(v[190] == 28);
	8501	try expect(v[191] == 29);
	8502	try expect(v[192] == 30);
	8503	try expect(v[193] == 31);
	8504	try expect(v[194] == 32);
	8505	try expect(v[195] == 33);
	8506	try expect(v[196] == 34);
	8507	try expect(v[197] == 35);
	8508	try expect(v[198] == 36);
	8509	try expect(v[199] == 37);
	8510	try expect(v[200] == 38);
	8511	try expect(v[201] == 39);
	8512	try expect(v[202] == 40);
	8513	try expect(v[203] == 41);
	8514	try expect(v[204] == 42);
	8515	try expect(v[205] == 43);
	8516	try expect(v[206] == 44);
	8517	try expect(v[207] == 45);
	8518	try expect(v[208] == 46);
	8519	try expect(v[209] == 47);
	8520	try expect(v[210] == 48);
	8521	try expect(v[211] == 49);
	8522	try expect(v[212] == 50);
	8523	try expect(v[213] == 51);
	8524	try expect(v[214] == 52);
	8525	try expect(v[215] == 53);
	8526	try expect(v[216] == 54);
	8527	try expect(v[217] == 55);
	8528	try expect(v[218] == 56);
	8529	try expect(v[219] == 57);
	8530	try expect(v[220] == 58);
	8531	try expect(v[221] == 59);
	8532	try expect(v[222] == 60);
	8533	try expect(v[223] == 61);
	8534	try expect(v[224] == 62);
	8535	try expect(v[225] == 63);
	8536	try expect(v[226] == 64);
	8537	try expect(v[227] == 65);
	8538	try expect(v[228] == 66);
	8539	try expect(v[229] == 67);
	8540	try expect(v[230] == 68);
	8541	try expect(v[231] == 69);
	8542	try expect(v[232] == 70);
	8543	try expect(v[233] == 71);
	8544	try expect(v[234] == 72);
	8545	try expect(v[235] == 73);
	8546	try expect(v[236] == 74);
	8547	try expect(v[237] == 75);
	8548	try expect(v[238] == 76);
	8549	try expect(v[239] == 77);
	8550	try expect(v[240] == 78);
	8551	try expect(v[241] == 79);
	8552	try expect(v[242] == 80);
	8553	try expect(v[243] == 81);
	8554	try expect(v[244] == 82);
	8555	try expect(v[245] == 83);
	8556	try expect(v[246] == 84);
	8557	try expect(v[247] == 85);
	8558	try expect(v[248] == 86);
	8559	try expect(v[249] == 87);
	8560	try expect(v[250] == 88);
	8561	try expect(v[251] == 89);
	8562	try expect(v[252] == 90);
	8563	try expect(v[253] == 91);
	8564	try expect(v[254] == 92);
	8565	try expect(v[255] == 93);
	8566	try expect(v[256] == 94);
	8567	try expect(v[257] == 95);
	8568	try expect(v[258] == 96);
	8569	try expect(v[259] == 97);
	8570	try expect(v[260] == 98);
	8571	try expect(v[261] == 99);
	8572	try expect(v[262] == 0);
	8573	try expect(v[263] == 1);
	8574	try expect(v[264] == 2);
	8575	try expect(v[265] == 3);
	8576	try expect(v[266] == 4);
	8577	try expect(v[267] == 5);
	8578	try expect(v[268] == 6);
	8579	try expect(v[269] == 7);
	8580	try expect(v[270] == 8);
	8581	try expect(v[271] == 9);
	8582	try expect(v[272] == 10);
	8583	try expect(v[273] == 11);
	8584	try expect(v[274] == 12);
	8585	try expect(v[275] == 13);
	8586	try expect(v[276] == 14);
	8587	try expect(v[277] == 15);
	8588	try expect(v[278] == 16);
	8589	try expect(v[279] == 17);
	8590	try expect(v[280] == 18);
	8591	try expect(v[281] == 19);
	8592	try expect(v[282] == 20);
	8593	try expect(v[283] == 21);
	8594	try expect(v[284] == 22);
	8595	try expect(v[285] == 23);
	8596	try expect(v[286] == 24);
	8597	try expect(v[287] == 25);
	8598	try expect(v[288] == 26);
	8599	try expect(v[289] == 27);
	8600	try expect(v[290] == 28);
	8601	try expect(v[291] == 29);
	8602	try expect(v[292] == 30);
	8603	try expect(v[293] == 31);
	8604	try expect(v[294] == 32);
	8605	try expect(v[295] == 33);
	8606	try expect(v[296] == 34);
	8607	try expect(v[297] == 35);
	8608	try expect(v[298] == 36);
	8609	try expect(v[299] == 37);
	8610	try expect(v[300] == 38);
	8611	try expect(v[301] == 39);
	8612	try expect(v[302] == 40);
	8613	try expect(v[303] == 41);
	8614	try expect(v[304] == 42);
	8615	try expect(v[305] == 43);
	8616	try expect(v[306] == 44);
	8617	try expect(v[307] == 45);
	8618	try expect(v[308] == 46);
	8619	try expect(v[309] == 47);
	8620	try expect(v[310] == 48);
	8621	try expect(v[311] == 49);
	8622	try expect(v[312] == 50);
	8623	try expect(v[313] == 51);
	8624	try expect(v[314] == 52);
	8625	try expect(v[315] == 53);
	8626	try expect(v[316] == 54);
	8627	try expect(v[317] == 55);
	8628	try expect(v[318] == 56);
	8629	try expect(v[319] == 57);
	8630	try expect(v[320] == 58);
	8631	try expect(v[321] == 59);
	8632	try expect(v[322] == 60);
	8633	try expect(v[323] == 61);
	8634	try expect(v[324] == 62);
	8635	try expect(v[325] == 63);
	8636	try expect(v[326] == 64);
	8637	try expect(v[327] == 65);
	8638	try expect(v[328] == 66);
	8639	try expect(v[329] == 67);
	8640	try expect(v[330] == 68);
	8641	try expect(v[331] == 69);
	8642	try expect(v[332] == 70);
	8643	try expect(v[333] == 71);
	8644	try expect(v[334] == 72);
	8645	try expect(v[335] == 73);
	8646	try expect(v[336] == 74);
	8647	try expect(v[337] == 75);
	8648	try expect(v[338] == 76);
	8649	try expect(v[339] == 77);
	8650	try expect(v[340] == 78);
	8651	try expect(v[341] == 79);
	8652	try expect(v[342] == 80);
	8653	try expect(v[343] == 81);
	8654	try expect(v[344] == 82);
	8655	try expect(v[345] == 83);
	8656	try expect(v[346] == 84);
	8657	try expect(v[347] == 85);
	8658	try expect(v[348] == 86);
	8659	try expect(v[349] == 87);
	8660	try expect(v[350] == 88);
	8661	try expect(v[351] == 89);
	8662	try expect(v[352] == 90);
	8663	try expect(v[353] == 91);
	8664	try expect(v[354] == 92);
	8665	try expect(v[355] == 93);
	8666	try expect(v[356] == 94);
	8667	try expect(v[357] == 95);
	8668	try expect(v[358] == 96);
	8669	try expect(v[359] == 97);
	8670	try expect(v[360] == 98);
	8671	try expect(v[361] == 99);
	8672	try expect(v[362] == 0);
	8673	try expect(v[363] == 1);
	8674	try expect(v[364] == 2);
	8675	try expect(v[365] == 3);
	8676	try expect(v[366] == 4);
	8677	try expect(v[367] == 5);
	8678	try expect(v[368] == 6);
	8679	try expect(v[369] == 7);
	8680	try expect(v[370] == 8);
	8681	try expect(v[371] == 9);
	8682	try expect(v[372] == 10);
	8683	try expect(v[373] == 11);
	8684	try expect(v[374] == 12);
	8685	try expect(v[375] == 13);
	8686	try expect(v[376] == 14);
	8687	try expect(v[377] == 15);
	8688	try expect(v[378] == 16);
	8689	try expect(v[379] == 17);
	8690	try expect(v[380] == 18);
	8691	try expect(v[381] == 19);
	8692	try expect(v[382] == 20);
	8693	try expect(v[383] == 21);
	8694	try expect(v[384] == 22);
	8695	try expect(v[385] == 23);
	8696	try expect(v[386] == 24);
	8697	try expect(v[387] == 25);
	8698	try expect(v[388] == 26);
	8699	try expect(v[389] == 27);
	8700	try expect(v[390] == 28);
	8701	try expect(v[391] == 29);
	8702	try expect(v[392] == 30);
	8703	try expect(v[393] == 31);
	8704	try expect(v[394] == 32);
	8705	try expect(v[395] == 33);
	8706	try expect(v[396] == 34);
	8707	try expect(v[397] == 35);
	8708	try expect(v[398] == 36);
	8709	try expect(v[399] == 37);
	8710	try expect(v[400] == 38);
	8711	try expect(v[401] == 39);
	8712	try expect(v[402] == 40);
	8713	try expect(v[403] == 41);
	8714	try expect(v[404] == 42);
	8715	try expect(v[405] == 43);
	8716	try expect(v[406] == 44);
	8717	try expect(v[407] == 45);
	8718	try expect(v[408] == 46);
	8719	try expect(v[409] == 47);
	8720	try expect(v[410] == 48);
	8721	try expect(v[411] == 49);
	8722	try expect(v[412] == 50);
	8723	try expect(v[413] == 51);
	8724	try expect(v[414] == 52);
	8725	try expect(v[415] == 53);
	8726	try expect(v[416] == 54);
	8727	try expect(v[417] == 55);
	8728	try expect(v[418] == 56);
	8729	try expect(v[419] == 57);
	8730	try expect(v[420] == 58);
	8731	try expect(v[421] == 59);
	8732	try expect(v[422] == 60);
	8733	try expect(v[423] == 61);
	8734	try expect(v[424] == 62);
	8735	try expect(v[425] == 63);
	8736	try expect(v[426] == 64);
	8737	try expect(v[427] == 65);
	8738	try expect(v[428] == 66);
	8739	try expect(v[429] == 67);
	8740	try expect(v[430] == 68);
	8741	try expect(v[431] == 69);
	8742	try expect(v[432] == 70);
	8743	try expect(v[433] == 71);
	8744	try expect(v[434] == 72);
	8745	try expect(v[435] == 73);
	8746	try expect(v[436] == 74);
	8747	try expect(v[437] == 75);
	8748	try expect(v[438] == 76);
	8749	try expect(v[439] == 77);
	8750	try expect(v[440] == 78);
	8751	try expect(v[441] == 79);
	8752	try expect(v[442] == 80);
	8753	try expect(v[443] == 81);
	8754	try expect(v[444] == 82);
	8755	try expect(v[445] == 83);
	8756	try expect(v[446] == 84);
	8757	try expect(v[447] == 85);
	8758	try expect(v[448] == 86);
	8759	try expect(v[449] == 87);
	8760	try expect(v[450] == 88);
	8761	try expect(v[451] == 89);
	8762	try expect(v[452] == 90);
	8763	try expect(v[453] == 91);
	8764	try expect(v[454] == 92);
	8765	try expect(v[455] == 93);
	8766	try expect(v[456] == 94);
	8767	try expect(v[457] == 95);
	8768	try expect(v[458] == 96);
	8769	try expect(v[459] == 97);
	8770	try expect(v[460] == 98);
	8771	try expect(v[461] == 99);
	8772	try expect(v[462] == 0);
	8773	try expect(v[463] == 1);
	8774	try expect(v[464] == 2);
	8775	try expect(v[465] == 3);
	8776	try expect(v[466] == 4);
	8777	try expect(v[467] == 5);
	8778	try expect(v[468] == 6);
	8779	try expect(v[469] == 7);
	8780	try expect(v[470] == 8);
	8781	try expect(v[471] == 9);
	8782	try expect(v[472] == 10);
	8783	try expect(v[473] == 11);
	8784	try expect(v[474] == 12);
	8785	try expect(v[475] == 13);
	8786	try expect(v[476] == 14);
	8787	try expect(v[477] == 15);
	8788	try expect(v[478] == 16);
	8789	try expect(v[479] == 17);
	8790	try expect(v[480] == 18);
	8791	try expect(v[481] == 19);
	8792	try expect(v[482] == 20);
	8793	try expect(v[483] == 21);
	8794	try expect(v[484] == 22);
	8795	try expect(v[485] == 23);
	8796	try expect(v[486] == 24);
	8797	try expect(v[487] == 25);
	8798	try expect(v[488] == 26);
	8799	try expect(v[489] == 27);
	8800	try expect(v[490] == 28);
	8801	try expect(v[491] == 29);
	8802	try expect(v[492] == 30);
	8803	try expect(v[493] == 31);
	8804	try expect(v[494] == 32);
	8805	try expect(v[495] == 33);
	8806	try expect(v[496] == 34);
	8807	try expect(v[497] == 35);
	8808	try expect(v[498] == 36);
	8809	try expect(v[499] == 37);
	8810	try expect(v[500] == 38);
	8811	try expect(v[501] == 39);
	8812	try expect(v[502] == 40);
	8813	try expect(v[503] == 41);
	8814	try expect(v[504] == 42);
	8815	try expect(v[505] == 43);
	8816	try expect(v[506] == 44);
	8817	try expect(v[507] == 45);
	8818	try expect(v[508] == 46);
	8819	try expect(v[509] == 47);
	8820	try expect(v[510] == 48);
	8821	try expect(v[511] == 49);
	8822	c_vector_512_u8(.{
	8823	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	8824	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	8825	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	8826	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	8827	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	8828	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	8829	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	8830	62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
	8831	78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
	8832	94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
	8833	10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
	8834	26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
	8835	42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
	8836	58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
	8837	74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
	8838	90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
	8839	6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
	8840	22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
	8841	38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
	8842	54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
	8843	70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
	8844	86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
	8845	2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
	8846	18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
	8847	34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
	8848	50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
	8849	66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
	8850	82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
	8851	98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
	8852	14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
	8853	30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
	8854	46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
	8855	}, 512);
	8856	c_test_vector_512_u8();
	8857	}
	8858
	8859	export fn zig_ret_vector_1_u16() @Vector(1, u16) {
	8860	return .{1};
	8861	}
	8862	export fn zig_vector_1_u16(v: @Vector(1, u16), i: usize) void {
	8863	expect(v[0] == 2) catch @panic("test failure");
	8864	expect(i == 1) catch @panic("test failure");
	8865	}
	8866
	8867	extern fn c_ret_vector_1_u16() @Vector(1, u16);
	8868	extern fn c_vector_1_u16(@Vector(1, u16), usize) void;
	8869	extern fn c_test_vector_1_u16() void;
	8870
	8871	test "@Vector(1, u16)" {
	8872	if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
	8873	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	8874	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	8875
	8876	const v = c_ret_vector_1_u16();
	8877	try expect(v[0] == 3);
	8878	c_vector_1_u16(.{4}, 1);
	8879	c_test_vector_1_u16();
	8880	}
	8881
	8882	export fn zig_ret_vector_2_u16() @Vector(2, u16) {
	8883	return .{ 5, 6 };
	8884	}
	8885	export fn zig_vector_2_u16(v: @Vector(2, u16), i: usize) void {
	8886	expect(v[0] == 7) catch @panic("test failure");
	8887	expect(v[1] == 8) catch @panic("test failure");
	8888	expect(i == 2) catch @panic("test failure");
	8889	}
	8890
	8891	extern fn c_ret_vector_2_u16() @Vector(2, u16);
	8892	extern fn c_vector_2_u16(@Vector(2, u16), usize) void;
	8893	extern fn c_test_vector_2_u16() void;
	8894
	8895	test "@Vector(2, u16)" {
	8896	if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
	8897	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	8898	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	8899	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	8900	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	8901	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) return error.SkipZigTest;
	8902
	8903	const v = c_ret_vector_2_u16();
	8904	try expect(v[0] == 9);
	8905	try expect(v[1] == 10);
	8906	c_vector_2_u16(.{ 11, 12 }, 2);
	8907	c_test_vector_2_u16();
	8908	}
	8909
	8910	export fn zig_ret_vector_3_u16() @Vector(3, u16) {
	8911	return .{ 13, 14, 15 };
	8912	}
	8913	export fn zig_vector_3_u16(v: @Vector(3, u16), i: usize) void {
	8914	expect(v[0] == 16) catch @panic("test failure");
	8915	expect(v[1] == 17) catch @panic("test failure");
	8916	expect(v[2] == 18) catch @panic("test failure");
	8917	expect(i == 3) catch @panic("test failure");
	8918	}
	8919
	8920	extern fn c_ret_vector_3_u16() @Vector(3, u16);
	8921	extern fn c_vector_3_u16(@Vector(3, u16), usize) void;
	8922	extern fn c_test_vector_3_u16() void;
	8923
	8924	test "@Vector(3, u16)" {
	8925	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	8926	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	8927	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	8928	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	8929	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag != .windows) return error.SkipZigTest;
	8930
	8931	const v = c_ret_vector_3_u16();
	8932	try expect(v[0] == 19);
	8933	try expect(v[1] == 20);
	8934	try expect(v[2] == 21);
	8935	c_vector_3_u16(.{ 22, 23, 24 }, 3);
	8936	c_test_vector_3_u16();
	8937	}
	8938
	8939	export fn zig_ret_vector_4_u16() @Vector(4, u16) {
	8940	return .{ 25, 26, 27, 28 };
	8941	}
	8942	export fn zig_vector_4_u16(v: @Vector(4, u16), i: usize) void {
	8943	expect(v[0] == 29) catch @panic("test failure");
	8944	expect(v[1] == 30) catch @panic("test failure");
	8945	expect(v[2] == 31) catch @panic("test failure");
	8946	expect(v[3] == 32) catch @panic("test failure");
	8947	expect(i == 4) catch @panic("test failure");
	8948	}
	8949	export fn zig_vector_4_u16_vector_4_u16(v0: @Vector(4, u16), v1: @Vector(4, u16), i: usize) void {
	8950	expect(v0[0] == 33) catch @panic("test failure");
	8951	expect(v0[1] == 34) catch @panic("test failure");
	8952	expect(v0[2] == 35) catch @panic("test failure");
	8953	expect(v0[3] == 36) catch @panic("test failure");
	8954	expect(v1[0] == 37) catch @panic("test failure");
	8955	expect(v1[1] == 38) catch @panic("test failure");
	8956	expect(v1[2] == 39) catch @panic("test failure");
	8957	expect(v1[3] == 40) catch @panic("test failure");
	8958	expect(i == 8) catch @panic("test failure");
	8959	}
	8960
	8961	extern fn c_ret_vector_4_u16() @Vector(4, u16);
	8962	extern fn c_vector_4_u16(@Vector(4, u16), usize) void;
	8963	extern fn c_vector_4_u16_vector_4_u16(@Vector(4, u16), @Vector(4, u16), usize) void;
	8964	extern fn c_test_vector_4_u16() void;
	8965
	8966	test "@Vector(4, u16)" {
	8967	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	8968	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	8969	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	8970	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
	8971
	8972	const v = c_ret_vector_4_u16();
	8973	try expect(v[0] == 41);
	8974	try expect(v[1] == 42);
	8975	try expect(v[2] == 43);
	8976	try expect(v[3] == 44);
	8977	c_vector_4_u16(.{ 45, 46, 47, 48 }, 4);
	8978	c_vector_4_u16_vector_4_u16(.{ 49, 50, 51, 52 }, .{ 53, 54, 55, 56 }, 8);
	8979	c_test_vector_4_u16();
	8980	}
	8981
	8982	export fn zig_ret_vector_6_u16() @Vector(6, u16) {
	8983	return .{ 41, 42, 43, 44, 45, 46 };
	8984	}
	8985	export fn zig_vector_6_u16(v: @Vector(6, u16), i: usize) void {
	8986	expect(v[0] == 47) catch @panic("test failure");
	8987	expect(v[1] == 48) catch @panic("test failure");
	8988	expect(v[2] == 49) catch @panic("test failure");
	8989	expect(v[3] == 50) catch @panic("test failure");
	8990	expect(v[4] == 51) catch @panic("test failure");
	8991	expect(v[5] == 52) catch @panic("test failure");
	8992	expect(i == 6) catch @panic("test failure");
	8993	}
	8994
	8995	extern fn c_ret_vector_6_u16() @Vector(6, u16);
	8996	extern fn c_vector_6_u16(@Vector(6, u16), usize) void;
	8997	extern fn c_test_vector_6_u16() void;
	8998
	8999	test "@Vector(6, u16)" {
	9000	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	9001	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	9002	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	9003
	9004	const v = c_ret_vector_6_u16();
	9005	try expect(v[0] == 53);
	9006	try expect(v[1] == 54);
	9007	try expect(v[2] == 55);
	9008	try expect(v[3] == 56);
	9009	try expect(v[4] == 57);
	9010	try expect(v[5] == 58);
	9011	c_vector_6_u16(.{ 59, 60, 61, 62, 63, 64 }, 6);
	9012	c_test_vector_6_u16();
	9013	}
	9014
	9015	export fn zig_ret_vector_8_u16() @Vector(8, u16) {
	9016	return .{ 65, 66, 67, 68, 69, 70, 71, 72 };
	9017	}
	9018	export fn zig_vector_8_u16(v: @Vector(8, u16), i: usize) void {
	9019	expect(v[0] == 73) catch @panic("test failure");
	9020	expect(v[1] == 74) catch @panic("test failure");
	9021	expect(v[2] == 75) catch @panic("test failure");
	9022	expect(v[3] == 76) catch @panic("test failure");
	9023	expect(v[4] == 77) catch @panic("test failure");
	9024	expect(v[5] == 78) catch @panic("test failure");
	9025	expect(v[6] == 79) catch @panic("test failure");
	9026	expect(v[7] == 80) catch @panic("test failure");
	9027	expect(i == 8) catch @panic("test failure");
	9028	}
	9029
	9030	extern fn c_ret_vector_8_u16() @Vector(8, u16);
	9031	extern fn c_vector_8_u16(@Vector(8, u16), usize) void;
	9032	extern fn c_test_vector_8_u16() void;
	9033
	9034	test "@Vector(8, u16)" {
	9035	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	9036
	9037	const v = c_ret_vector_8_u16();
	9038	try expect(v[0] == 81);
	9039	try expect(v[1] == 82);
	9040	try expect(v[2] == 83);
	9041	try expect(v[3] == 84);
	9042	try expect(v[4] == 85);
	9043	try expect(v[5] == 86);
	9044	try expect(v[6] == 87);
	9045	try expect(v[7] == 88);
	9046	c_vector_8_u16(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8);
	9047	c_test_vector_8_u16();
	9048	}
	9049
	9050	export fn zig_ret_vector_12_u16() @Vector(12, u16) {
	9051	return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 };
	9052	}
	9053	export fn zig_vector_12_u16(v: @Vector(12, u16), i: usize) void {
	9054	expect(v[0] == 109) catch @panic("test failure");
	9055	expect(v[1] == 110) catch @panic("test failure");
	9056	expect(v[2] == 111) catch @panic("test failure");
	9057	expect(v[3] == 112) catch @panic("test failure");
	9058	expect(v[4] == 113) catch @panic("test failure");
	9059	expect(v[5] == 114) catch @panic("test failure");
	9060	expect(v[6] == 115) catch @panic("test failure");
	9061	expect(v[7] == 116) catch @panic("test failure");
	9062	expect(v[8] == 117) catch @panic("test failure");
	9063	expect(v[9] == 118) catch @panic("test failure");
	9064	expect(v[10] == 119) catch @panic("test failure");
	9065	expect(v[11] == 120) catch @panic("test failure");
	9066	expect(i == 12) catch @panic("test failure");
	9067	}
	9068
	9069	extern fn c_ret_vector_12_u16() @Vector(12, u16);
	9070	extern fn c_vector_12_u16(@Vector(12, u16), usize) void;
	9071	extern fn c_test_vector_12_u16() void;
	9072
	9073	test "@Vector(12, u16)" {
	9074	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	9075	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	9076	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	9077	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	9078	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	9079
	9080	const v = c_ret_vector_12_u16();
	9081	try expect(v[0] == 121);
	9082	try expect(v[1] == 122);
	9083	try expect(v[2] == 123);
	9084	try expect(v[3] == 124);
	9085	try expect(v[4] == 125);
	9086	try expect(v[5] == 126);
	9087	try expect(v[6] == 127);
	9088	try expect(v[7] == 128);
	9089	try expect(v[8] == 129);
	9090	try expect(v[9] == 130);
	9091	try expect(v[10] == 131);
	9092	try expect(v[11] == 132);
	9093	c_vector_12_u16(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12);
	9094	c_test_vector_12_u16();
	9095	}
	9096
	9097	export fn zig_ret_vector_16_u16() @Vector(16, u16) {
	9098	return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 };
	9099	}
	9100	export fn zig_vector_16_u16(v: @Vector(16, u16), i: usize) void {
	9101	expect(v[0] == 161) catch @panic("test failure");
	9102	expect(v[1] == 162) catch @panic("test failure");
	9103	expect(v[2] == 163) catch @panic("test failure");
	9104	expect(v[3] == 164) catch @panic("test failure");
	9105	expect(v[4] == 165) catch @panic("test failure");
	9106	expect(v[5] == 166) catch @panic("test failure");
	9107	expect(v[6] == 167) catch @panic("test failure");
	9108	expect(v[7] == 168) catch @panic("test failure");
	9109	expect(v[8] == 169) catch @panic("test failure");
	9110	expect(v[9] == 170) catch @panic("test failure");
	9111	expect(v[10] == 171) catch @panic("test failure");
	9112	expect(v[11] == 172) catch @panic("test failure");
	9113	expect(v[12] == 173) catch @panic("test failure");
	9114	expect(v[13] == 174) catch @panic("test failure");
	9115	expect(v[14] == 175) catch @panic("test failure");
	9116	expect(v[15] == 176) catch @panic("test failure");
	9117	expect(i == 16) catch @panic("test failure");
	9118	}
	9119
	9120	extern fn c_ret_vector_16_u16() @Vector(16, u16);
	9121	extern fn c_vector_16_u16(@Vector(16, u16), usize) void;
	9122	extern fn c_test_vector_16_u16() void;
	9123
	9124	test "@Vector(16, u16)" {
	9125	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	9126	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	9127	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	9128	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	9129
	9130	const v = c_ret_vector_16_u16();
	9131	try expect(v[0] == 177);
	9132	try expect(v[1] == 178);
	9133	try expect(v[2] == 179);
	9134	try expect(v[3] == 180);
	9135	try expect(v[4] == 181);
	9136	try expect(v[5] == 182);
	9137	try expect(v[6] == 183);
	9138	try expect(v[7] == 184);
	9139	try expect(v[8] == 185);
	9140	try expect(v[9] == 186);
	9141	try expect(v[10] == 187);
	9142	try expect(v[11] == 188);
	9143	try expect(v[12] == 189);
	9144	try expect(v[13] == 190);
	9145	try expect(v[14] == 191);
	9146	try expect(v[15] == 192);
	9147	c_vector_16_u16(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16);
	9148	c_test_vector_16_u16();
	9149	}
	9150
	9151	export fn zig_ret_vector_24_u16() @Vector(24, u16) {
	9152	return .{
	9153	209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
	9154	225, 226, 227, 228, 229, 230, 231, 232,
	9155	};
	9156	}
	9157	export fn zig_vector_24_u16(v: @Vector(24, u16), i: usize) void {
	9158	expect(v[0] == 233) catch @panic("test failure");
	9159	expect(v[1] == 234) catch @panic("test failure");
	9160	expect(v[2] == 235) catch @panic("test failure");
	9161	expect(v[3] == 236) catch @panic("test failure");
	9162	expect(v[4] == 237) catch @panic("test failure");
	9163	expect(v[5] == 238) catch @panic("test failure");
	9164	expect(v[6] == 239) catch @panic("test failure");
	9165	expect(v[7] == 240) catch @panic("test failure");
	9166	expect(v[8] == 241) catch @panic("test failure");
	9167	expect(v[9] == 242) catch @panic("test failure");
	9168	expect(v[10] == 243) catch @panic("test failure");
	9169	expect(v[11] == 244) catch @panic("test failure");
	9170	expect(v[12] == 245) catch @panic("test failure");
	9171	expect(v[13] == 246) catch @panic("test failure");
	9172	expect(v[14] == 247) catch @panic("test failure");
	9173	expect(v[15] == 248) catch @panic("test failure");
	9174	expect(v[16] == 249) catch @panic("test failure");
	9175	expect(v[17] == 250) catch @panic("test failure");
	9176	expect(v[18] == 251) catch @panic("test failure");
	9177	expect(v[19] == 252) catch @panic("test failure");
	9178	expect(v[20] == 253) catch @panic("test failure");
	9179	expect(v[21] == 254) catch @panic("test failure");
	9180	expect(v[22] == 255) catch @panic("test failure");
	9181	expect(v[23] == 256) catch @panic("test failure");
	9182	expect(i == 24) catch @panic("test failure");
	9183	}
	9184
	9185	extern fn c_ret_vector_24_u16() @Vector(24, u16);
	9186	extern fn c_vector_24_u16(@Vector(24, u16), usize) void;
	9187	extern fn c_test_vector_24_u16() void;
	9188
	9189	test "@Vector(24, u16)" {
	9190	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	9191	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	9192	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	9193	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	9194	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	9195
	9196	const v = c_ret_vector_24_u16();
	9197	try expect(v[0] == 257);
	9198	try expect(v[1] == 258);
	9199	try expect(v[2] == 259);
	9200	try expect(v[3] == 260);
	9201	try expect(v[4] == 261);
	9202	try expect(v[5] == 262);
	9203	try expect(v[6] == 263);
	9204	try expect(v[7] == 264);
	9205	try expect(v[8] == 265);
	9206	try expect(v[9] == 266);
	9207	try expect(v[10] == 267);
	9208	try expect(v[11] == 268);
	9209	try expect(v[12] == 269);
	9210	try expect(v[13] == 270);
	9211	try expect(v[14] == 271);
	9212	try expect(v[15] == 272);
	9213	try expect(v[16] == 273);
	9214	try expect(v[17] == 274);
	9215	try expect(v[18] == 275);
	9216	try expect(v[19] == 276);
	9217	try expect(v[20] == 277);
	9218	try expect(v[21] == 278);
	9219	try expect(v[22] == 279);
	9220	try expect(v[23] == 280);
	9221	c_vector_24_u16(.{
	9222	281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
	9223	297, 298, 299, 300, 301, 302, 303, 304,
	9224	}, 24);
	9225	c_test_vector_24_u16();
	9226	}
	9227
	9228	export fn zig_ret_vector_32_u16() @Vector(32, u16) {
	9229	return .{
	9230	305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
	9231	321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
	9232	};
	9233	}
	9234	export fn zig_vector_32_u16(v: @Vector(32, u16), i: usize) void {
	9235	expect(v[0] == 337) catch @panic("test failure");
	9236	expect(v[1] == 338) catch @panic("test failure");
	9237	expect(v[2] == 339) catch @panic("test failure");
	9238	expect(v[3] == 340) catch @panic("test failure");
	9239	expect(v[4] == 341) catch @panic("test failure");
	9240	expect(v[5] == 342) catch @panic("test failure");
	9241	expect(v[6] == 343) catch @panic("test failure");
	9242	expect(v[7] == 344) catch @panic("test failure");
	9243	expect(v[8] == 345) catch @panic("test failure");
	9244	expect(v[9] == 346) catch @panic("test failure");
	9245	expect(v[10] == 347) catch @panic("test failure");
	9246	expect(v[11] == 348) catch @panic("test failure");
	9247	expect(v[12] == 349) catch @panic("test failure");
	9248	expect(v[13] == 350) catch @panic("test failure");
	9249	expect(v[14] == 351) catch @panic("test failure");
	9250	expect(v[15] == 352) catch @panic("test failure");
	9251	expect(v[16] == 353) catch @panic("test failure");
	9252	expect(v[17] == 354) catch @panic("test failure");
	9253	expect(v[18] == 355) catch @panic("test failure");
	9254	expect(v[19] == 356) catch @panic("test failure");
	9255	expect(v[20] == 357) catch @panic("test failure");
	9256	expect(v[21] == 358) catch @panic("test failure");
	9257	expect(v[22] == 359) catch @panic("test failure");
	9258	expect(v[23] == 360) catch @panic("test failure");
	9259	expect(v[24] == 361) catch @panic("test failure");
	9260	expect(v[25] == 362) catch @panic("test failure");
	9261	expect(v[26] == 363) catch @panic("test failure");
	9262	expect(v[27] == 364) catch @panic("test failure");
	9263	expect(v[28] == 365) catch @panic("test failure");
	9264	expect(v[29] == 366) catch @panic("test failure");
	9265	expect(v[30] == 367) catch @panic("test failure");
	9266	expect(v[31] == 368) catch @panic("test failure");
	9267	expect(i == 32) catch @panic("test failure");
	9268	}
	9269
	9270	extern fn c_ret_vector_32_u16() @Vector(32, u16);
	9271	extern fn c_vector_32_u16(@Vector(32, u16), usize) void;
	9272	extern fn c_test_vector_32_u16() void;
	9273
	9274	test "@Vector(32, u16)" {
	9275	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	9276	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	9277	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	9278	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	9279
	9280	const v = c_ret_vector_32_u16();
	9281	try expect(v[0] == 369);
	9282	try expect(v[1] == 370);
	9283	try expect(v[2] == 371);
	9284	try expect(v[3] == 372);
	9285	try expect(v[4] == 373);
	9286	try expect(v[5] == 374);
	9287	try expect(v[6] == 375);
	9288	try expect(v[7] == 376);
	9289	try expect(v[8] == 377);
	9290	try expect(v[9] == 378);
	9291	try expect(v[10] == 379);
	9292	try expect(v[11] == 380);
	9293	try expect(v[12] == 381);
	9294	try expect(v[13] == 382);
	9295	try expect(v[14] == 383);
	9296	try expect(v[15] == 384);
	9297	try expect(v[16] == 385);
	9298	try expect(v[17] == 386);
	9299	try expect(v[18] == 387);
	9300	try expect(v[19] == 388);
	9301	try expect(v[20] == 389);
	9302	try expect(v[21] == 390);
	9303	try expect(v[22] == 391);
	9304	try expect(v[23] == 392);
	9305	try expect(v[24] == 393);
	9306	try expect(v[25] == 394);
	9307	try expect(v[26] == 395);
	9308	try expect(v[27] == 396);
	9309	try expect(v[28] == 397);
	9310	try expect(v[29] == 398);
	9311	try expect(v[30] == 399);
	9312	try expect(v[31] == 400);
	9313	c_vector_32_u16(.{
	9314	401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416,
	9315	417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432,
	9316	}, 32);
	9317	c_test_vector_32_u16();
	9318	}
	9319
	9320	export fn zig_ret_vector_48_u16() @Vector(48, u16) {
	9321	return .{
	9322	433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448,
	9323	449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
	9324	465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,
	9325	};
	9326	}
	9327	export fn zig_vector_48_u16(v: @Vector(48, u16), i: usize) void {
	9328	expect(v[0] == 481) catch @panic("test failure");
	9329	expect(v[1] == 482) catch @panic("test failure");
	9330	expect(v[2] == 483) catch @panic("test failure");
	9331	expect(v[3] == 484) catch @panic("test failure");
	9332	expect(v[4] == 485) catch @panic("test failure");
	9333	expect(v[5] == 486) catch @panic("test failure");
	9334	expect(v[6] == 487) catch @panic("test failure");
	9335	expect(v[7] == 488) catch @panic("test failure");
	9336	expect(v[8] == 489) catch @panic("test failure");
	9337	expect(v[9] == 490) catch @panic("test failure");
	9338	expect(v[10] == 491) catch @panic("test failure");
	9339	expect(v[11] == 492) catch @panic("test failure");
	9340	expect(v[12] == 493) catch @panic("test failure");
	9341	expect(v[13] == 494) catch @panic("test failure");
	9342	expect(v[14] == 495) catch @panic("test failure");
	9343	expect(v[15] == 496) catch @panic("test failure");
	9344	expect(v[16] == 497) catch @panic("test failure");
	9345	expect(v[17] == 498) catch @panic("test failure");
	9346	expect(v[18] == 499) catch @panic("test failure");
	9347	expect(v[19] == 500) catch @panic("test failure");
	9348	expect(v[20] == 501) catch @panic("test failure");
	9349	expect(v[21] == 502) catch @panic("test failure");
	9350	expect(v[22] == 503) catch @panic("test failure");
	9351	expect(v[23] == 504) catch @panic("test failure");
	9352	expect(v[24] == 505) catch @panic("test failure");
	9353	expect(v[25] == 506) catch @panic("test failure");
	9354	expect(v[26] == 507) catch @panic("test failure");
	9355	expect(v[27] == 508) catch @panic("test failure");
	9356	expect(v[28] == 509) catch @panic("test failure");
	9357	expect(v[29] == 510) catch @panic("test failure");
	9358	expect(v[30] == 511) catch @panic("test failure");
	9359	expect(v[31] == 512) catch @panic("test failure");
	9360	expect(v[32] == 513) catch @panic("test failure");
	9361	expect(v[33] == 514) catch @panic("test failure");
	9362	expect(v[34] == 515) catch @panic("test failure");
	9363	expect(v[35] == 516) catch @panic("test failure");
	9364	expect(v[36] == 517) catch @panic("test failure");
	9365	expect(v[37] == 518) catch @panic("test failure");
	9366	expect(v[38] == 519) catch @panic("test failure");
	9367	expect(v[39] == 520) catch @panic("test failure");
	9368	expect(v[40] == 521) catch @panic("test failure");
	9369	expect(v[41] == 522) catch @panic("test failure");
	9370	expect(v[42] == 523) catch @panic("test failure");
	9371	expect(v[43] == 524) catch @panic("test failure");
	9372	expect(v[44] == 525) catch @panic("test failure");
	9373	expect(v[45] == 526) catch @panic("test failure");
	9374	expect(v[46] == 527) catch @panic("test failure");
	9375	expect(v[47] == 528) catch @panic("test failure");
	9376	expect(i == 48) catch @panic("test failure");
	9377	}
	9378
	9379	extern fn c_ret_vector_48_u16() @Vector(48, u16);
	9380	extern fn c_vector_48_u16(@Vector(48, u16), usize) void;
	9381	extern fn c_test_vector_48_u16() void;
	9382
	9383	test "@Vector(48, u16)" {
	9384	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	9385	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	9386	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	9387	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	9388	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	9389
	9390	const v = c_ret_vector_48_u16();
	9391	try expect(v[0] == 529);
	9392	try expect(v[1] == 530);
	9393	try expect(v[2] == 531);
	9394	try expect(v[3] == 532);
	9395	try expect(v[4] == 533);
	9396	try expect(v[5] == 534);
	9397	try expect(v[6] == 535);
	9398	try expect(v[7] == 536);
	9399	try expect(v[8] == 537);
	9400	try expect(v[9] == 538);
	9401	try expect(v[10] == 539);
	9402	try expect(v[11] == 540);
	9403	try expect(v[12] == 541);
	9404	try expect(v[13] == 542);
	9405	try expect(v[14] == 543);
	9406	try expect(v[15] == 544);
	9407	try expect(v[16] == 545);
	9408	try expect(v[17] == 546);
	9409	try expect(v[18] == 547);
	9410	try expect(v[19] == 548);
	9411	try expect(v[20] == 549);
	9412	try expect(v[21] == 550);
	9413	try expect(v[22] == 551);
	9414	try expect(v[23] == 552);
	9415	try expect(v[24] == 553);
	9416	try expect(v[25] == 554);
	9417	try expect(v[26] == 555);
	9418	try expect(v[27] == 556);
	9419	try expect(v[28] == 557);
	9420	try expect(v[29] == 558);
	9421	try expect(v[30] == 559);
	9422	try expect(v[31] == 560);
	9423	try expect(v[32] == 561);
	9424	try expect(v[33] == 562);
	9425	try expect(v[34] == 563);
	9426	try expect(v[35] == 564);
	9427	try expect(v[36] == 565);
	9428	try expect(v[37] == 566);
	9429	try expect(v[38] == 567);
	9430	try expect(v[39] == 568);
	9431	try expect(v[40] == 569);
	9432	try expect(v[41] == 570);
	9433	try expect(v[42] == 571);
	9434	try expect(v[43] == 572);
	9435	try expect(v[44] == 573);
	9436	try expect(v[45] == 574);
	9437	try expect(v[46] == 575);
	9438	try expect(v[47] == 576);
	9439	c_vector_48_u16(.{
	9440	577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
	9441	593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,
	9442	609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
	9443	}, 48);
	9444	c_test_vector_48_u16();
	9445	}
	9446
	9447	export fn zig_ret_vector_64_u16() @Vector(64, u16) {
	9448	return .{
	9449	625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640,
	9450	641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656,
	9451	657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672,
	9452	673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688,
	9453	};
	9454	}
	9455	export fn zig_vector_64_u16(v: @Vector(64, u16), i: usize) void {
	9456	expect(v[0] == 689) catch @panic("test failure");
	9457	expect(v[1] == 690) catch @panic("test failure");
	9458	expect(v[2] == 691) catch @panic("test failure");
	9459	expect(v[3] == 692) catch @panic("test failure");
	9460	expect(v[4] == 693) catch @panic("test failure");
	9461	expect(v[5] == 694) catch @panic("test failure");
	9462	expect(v[6] == 695) catch @panic("test failure");
	9463	expect(v[7] == 696) catch @panic("test failure");
	9464	expect(v[8] == 697) catch @panic("test failure");
	9465	expect(v[9] == 698) catch @panic("test failure");
	9466	expect(v[10] == 699) catch @panic("test failure");
	9467	expect(v[11] == 700) catch @panic("test failure");
	9468	expect(v[12] == 701) catch @panic("test failure");
	9469	expect(v[13] == 702) catch @panic("test failure");
	9470	expect(v[14] == 703) catch @panic("test failure");
	9471	expect(v[15] == 704) catch @panic("test failure");
	9472	expect(v[16] == 705) catch @panic("test failure");
	9473	expect(v[17] == 706) catch @panic("test failure");
	9474	expect(v[18] == 707) catch @panic("test failure");
	9475	expect(v[19] == 708) catch @panic("test failure");
	9476	expect(v[20] == 709) catch @panic("test failure");
	9477	expect(v[21] == 710) catch @panic("test failure");
	9478	expect(v[22] == 711) catch @panic("test failure");
	9479	expect(v[23] == 712) catch @panic("test failure");
	9480	expect(v[24] == 713) catch @panic("test failure");
	9481	expect(v[25] == 714) catch @panic("test failure");
	9482	expect(v[26] == 715) catch @panic("test failure");
	9483	expect(v[27] == 716) catch @panic("test failure");
	9484	expect(v[28] == 717) catch @panic("test failure");
	9485	expect(v[29] == 718) catch @panic("test failure");
	9486	expect(v[30] == 719) catch @panic("test failure");
	9487	expect(v[31] == 720) catch @panic("test failure");
	9488	expect(v[32] == 721) catch @panic("test failure");
	9489	expect(v[33] == 722) catch @panic("test failure");
	9490	expect(v[34] == 723) catch @panic("test failure");
	9491	expect(v[35] == 724) catch @panic("test failure");
	9492	expect(v[36] == 725) catch @panic("test failure");
	9493	expect(v[37] == 726) catch @panic("test failure");
	9494	expect(v[38] == 727) catch @panic("test failure");
	9495	expect(v[39] == 728) catch @panic("test failure");
	9496	expect(v[40] == 729) catch @panic("test failure");
	9497	expect(v[41] == 730) catch @panic("test failure");
	9498	expect(v[42] == 731) catch @panic("test failure");
	9499	expect(v[43] == 732) catch @panic("test failure");
	9500	expect(v[44] == 733) catch @panic("test failure");
	9501	expect(v[45] == 734) catch @panic("test failure");
	9502	expect(v[46] == 735) catch @panic("test failure");
	9503	expect(v[47] == 736) catch @panic("test failure");
	9504	expect(v[48] == 737) catch @panic("test failure");
	9505	expect(v[49] == 738) catch @panic("test failure");
	9506	expect(v[50] == 739) catch @panic("test failure");
	9507	expect(v[51] == 740) catch @panic("test failure");
	9508	expect(v[52] == 741) catch @panic("test failure");
	9509	expect(v[53] == 742) catch @panic("test failure");
	9510	expect(v[54] == 743) catch @panic("test failure");
	9511	expect(v[55] == 744) catch @panic("test failure");
	9512	expect(v[56] == 745) catch @panic("test failure");
	9513	expect(v[57] == 746) catch @panic("test failure");
	9514	expect(v[58] == 747) catch @panic("test failure");
	9515	expect(v[59] == 748) catch @panic("test failure");
	9516	expect(v[60] == 749) catch @panic("test failure");
	9517	expect(v[61] == 750) catch @panic("test failure");
	9518	expect(v[62] == 751) catch @panic("test failure");
	9519	expect(v[63] == 752) catch @panic("test failure");
	9520	expect(i == 64) catch @panic("test failure");
	9521	}
	9522
	9523	extern fn c_ret_vector_64_u16() @Vector(64, u16);
	9524	extern fn c_vector_64_u16(@Vector(64, u16), usize) void;
	9525	extern fn c_test_vector_64_u16() void;
	9526
	9527	test "@Vector(64, u16)" {
	9528	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	9529	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	9530	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	9531	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	9532	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	9533
	9534	const v = c_ret_vector_64_u16();
	9535	try expect(v[0] == 753);
	9536	try expect(v[1] == 754);
	9537	try expect(v[2] == 755);
	9538	try expect(v[3] == 756);
	9539	try expect(v[4] == 757);
	9540	try expect(v[5] == 758);
	9541	try expect(v[6] == 759);
	9542	try expect(v[7] == 760);
	9543	try expect(v[8] == 761);
	9544	try expect(v[9] == 762);
	9545	try expect(v[10] == 763);
	9546	try expect(v[11] == 764);
	9547	try expect(v[12] == 765);
	9548	try expect(v[13] == 766);
	9549	try expect(v[14] == 767);
	9550	try expect(v[15] == 768);
	9551	try expect(v[16] == 769);
	9552	try expect(v[17] == 770);
	9553	try expect(v[18] == 771);
	9554	try expect(v[19] == 772);
	9555	try expect(v[20] == 773);
	9556	try expect(v[21] == 774);
	9557	try expect(v[22] == 775);
	9558	try expect(v[23] == 776);
	9559	try expect(v[24] == 777);
	9560	try expect(v[25] == 778);
	9561	try expect(v[26] == 779);
	9562	try expect(v[27] == 780);
	9563	try expect(v[28] == 781);
	9564	try expect(v[29] == 782);
	9565	try expect(v[30] == 783);
	9566	try expect(v[31] == 784);
	9567	try expect(v[32] == 785);
	9568	try expect(v[33] == 786);
	9569	try expect(v[34] == 787);
	9570	try expect(v[35] == 788);
	9571	try expect(v[36] == 789);
	9572	try expect(v[37] == 790);
	9573	try expect(v[38] == 791);
	9574	try expect(v[39] == 792);
	9575	try expect(v[40] == 793);
	9576	try expect(v[41] == 794);
	9577	try expect(v[42] == 795);
	9578	try expect(v[43] == 796);
	9579	try expect(v[44] == 797);
	9580	try expect(v[45] == 798);
	9581	try expect(v[46] == 799);
	9582	try expect(v[47] == 800);
	9583	try expect(v[48] == 801);
	9584	try expect(v[49] == 802);
	9585	try expect(v[50] == 803);
	9586	try expect(v[51] == 804);
	9587	try expect(v[52] == 805);
	9588	try expect(v[53] == 806);
	9589	try expect(v[54] == 807);
	9590	try expect(v[55] == 808);
	9591	try expect(v[56] == 809);
	9592	try expect(v[57] == 810);
	9593	try expect(v[58] == 811);
	9594	try expect(v[59] == 812);
	9595	try expect(v[60] == 813);
	9596	try expect(v[61] == 814);
	9597	try expect(v[62] == 815);
	9598	try expect(v[63] == 816);
	9599	c_vector_64_u16(.{
	9600	817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832,
	9601	833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848,
	9602	849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864,
	9603	865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880,
	9604	}, 64);
	9605	c_test_vector_64_u16();
	9606	}
	9607
	9608	export fn zig_ret_vector_96_u16() @Vector(96, u16) {
	9609	return .{
	9610	890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905,
	9611	906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921,
	9612	922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937,
	9613	938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953,
	9614	954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969,
	9615	970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985,
	9616	};
	9617	}
	9618	export fn zig_vector_96_u16(v: @Vector(96, u16), i: usize) void {
	9619	expect(v[0] == 986) catch @panic("test failure");
	9620	expect(v[1] == 987) catch @panic("test failure");
	9621	expect(v[2] == 988) catch @panic("test failure");
	9622	expect(v[3] == 989) catch @panic("test failure");
	9623	expect(v[4] == 990) catch @panic("test failure");
	9624	expect(v[5] == 991) catch @panic("test failure");
	9625	expect(v[6] == 992) catch @panic("test failure");
	9626	expect(v[7] == 993) catch @panic("test failure");
	9627	expect(v[8] == 994) catch @panic("test failure");
	9628	expect(v[9] == 995) catch @panic("test failure");
	9629	expect(v[10] == 996) catch @panic("test failure");
	9630	expect(v[11] == 997) catch @panic("test failure");
	9631	expect(v[12] == 998) catch @panic("test failure");
	9632	expect(v[13] == 999) catch @panic("test failure");
	9633	expect(v[14] == 1000) catch @panic("test failure");
	9634	expect(v[15] == 1001) catch @panic("test failure");
	9635	expect(v[16] == 1002) catch @panic("test failure");
	9636	expect(v[17] == 1003) catch @panic("test failure");
	9637	expect(v[18] == 1004) catch @panic("test failure");
	9638	expect(v[19] == 1005) catch @panic("test failure");
	9639	expect(v[20] == 1006) catch @panic("test failure");
	9640	expect(v[21] == 1007) catch @panic("test failure");
	9641	expect(v[22] == 1008) catch @panic("test failure");
	9642	expect(v[23] == 1009) catch @panic("test failure");
	9643	expect(v[24] == 1010) catch @panic("test failure");
	9644	expect(v[25] == 1011) catch @panic("test failure");
	9645	expect(v[26] == 1012) catch @panic("test failure");
	9646	expect(v[27] == 1013) catch @panic("test failure");
	9647	expect(v[28] == 1014) catch @panic("test failure");
	9648	expect(v[29] == 1015) catch @panic("test failure");
	9649	expect(v[30] == 1016) catch @panic("test failure");
	9650	expect(v[31] == 1017) catch @panic("test failure");
	9651	expect(v[32] == 1018) catch @panic("test failure");
	9652	expect(v[33] == 1019) catch @panic("test failure");
	9653	expect(v[34] == 1020) catch @panic("test failure");
	9654	expect(v[35] == 1021) catch @panic("test failure");
	9655	expect(v[36] == 1022) catch @panic("test failure");
	9656	expect(v[37] == 1023) catch @panic("test failure");
	9657	expect(v[38] == 1024) catch @panic("test failure");
	9658	expect(v[39] == 1025) catch @panic("test failure");
	9659	expect(v[40] == 1026) catch @panic("test failure");
	9660	expect(v[41] == 1027) catch @panic("test failure");
	9661	expect(v[42] == 1028) catch @panic("test failure");
	9662	expect(v[43] == 1029) catch @panic("test failure");
	9663	expect(v[44] == 1030) catch @panic("test failure");
	9664	expect(v[45] == 1031) catch @panic("test failure");
	9665	expect(v[46] == 1032) catch @panic("test failure");
	9666	expect(v[47] == 1033) catch @panic("test failure");
	9667	expect(v[48] == 1034) catch @panic("test failure");
	9668	expect(v[49] == 1035) catch @panic("test failure");
	9669	expect(v[50] == 1036) catch @panic("test failure");
	9670	expect(v[51] == 1037) catch @panic("test failure");
	9671	expect(v[52] == 1038) catch @panic("test failure");
	9672	expect(v[53] == 1039) catch @panic("test failure");
	9673	expect(v[54] == 1040) catch @panic("test failure");
	9674	expect(v[55] == 1041) catch @panic("test failure");
	9675	expect(v[56] == 1042) catch @panic("test failure");
	9676	expect(v[57] == 1043) catch @panic("test failure");
	9677	expect(v[58] == 1044) catch @panic("test failure");
	9678	expect(v[59] == 1045) catch @panic("test failure");
	9679	expect(v[60] == 1046) catch @panic("test failure");
	9680	expect(v[61] == 1047) catch @panic("test failure");
	9681	expect(v[62] == 1048) catch @panic("test failure");
	9682	expect(v[63] == 1049) catch @panic("test failure");
	9683	expect(v[64] == 1050) catch @panic("test failure");
	9684	expect(v[65] == 1051) catch @panic("test failure");
	9685	expect(v[66] == 1052) catch @panic("test failure");
	9686	expect(v[67] == 1053) catch @panic("test failure");
	9687	expect(v[68] == 1054) catch @panic("test failure");
	9688	expect(v[69] == 1055) catch @panic("test failure");
	9689	expect(v[70] == 1056) catch @panic("test failure");
	9690	expect(v[71] == 1057) catch @panic("test failure");
	9691	expect(v[72] == 1058) catch @panic("test failure");
	9692	expect(v[73] == 1059) catch @panic("test failure");
	9693	expect(v[74] == 1060) catch @panic("test failure");
	9694	expect(v[75] == 1061) catch @panic("test failure");
	9695	expect(v[76] == 1062) catch @panic("test failure");
	9696	expect(v[77] == 1063) catch @panic("test failure");
	9697	expect(v[78] == 1064) catch @panic("test failure");
	9698	expect(v[79] == 1065) catch @panic("test failure");
	9699	expect(v[80] == 1066) catch @panic("test failure");
	9700	expect(v[81] == 1067) catch @panic("test failure");
	9701	expect(v[82] == 1068) catch @panic("test failure");
	9702	expect(v[83] == 1069) catch @panic("test failure");
	9703	expect(v[84] == 1070) catch @panic("test failure");
	9704	expect(v[85] == 1071) catch @panic("test failure");
	9705	expect(v[86] == 1072) catch @panic("test failure");
	9706	expect(v[87] == 1073) catch @panic("test failure");
	9707	expect(v[88] == 1074) catch @panic("test failure");
	9708	expect(v[89] == 1075) catch @panic("test failure");
	9709	expect(v[90] == 1076) catch @panic("test failure");
	9710	expect(v[91] == 1077) catch @panic("test failure");
	9711	expect(v[92] == 1078) catch @panic("test failure");
	9712	expect(v[93] == 1079) catch @panic("test failure");
	9713	expect(v[94] == 1080) catch @panic("test failure");
	9714	expect(v[95] == 1081) catch @panic("test failure");
	9715	expect(i == 96) catch @panic("test failure");
	9716	}
	9717
	9718	extern fn c_ret_vector_96_u16() @Vector(96, u16);
	9719	extern fn c_vector_96_u16(@Vector(96, u16), usize) void;
	9720	extern fn c_test_vector_96_u16() void;
	9721
	9722	test "@Vector(96, u16)" {
	9723	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	9724	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	9725	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	9726	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	9727	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	9728
	9729	const v = c_ret_vector_96_u16();
	9730	try expect(v[0] == 1082);
	9731	try expect(v[1] == 1083);
	9732	try expect(v[2] == 1084);
	9733	try expect(v[3] == 1085);
	9734	try expect(v[4] == 1086);
	9735	try expect(v[5] == 1087);
	9736	try expect(v[6] == 1088);
	9737	try expect(v[7] == 1089);
	9738	try expect(v[8] == 1090);
	9739	try expect(v[9] == 1091);
	9740	try expect(v[10] == 1092);
	9741	try expect(v[11] == 1093);
	9742	try expect(v[12] == 1094);
	9743	try expect(v[13] == 1095);
	9744	try expect(v[14] == 1096);
	9745	try expect(v[15] == 1097);
	9746	try expect(v[16] == 1098);
	9747	try expect(v[17] == 1099);
	9748	try expect(v[18] == 1100);
	9749	try expect(v[19] == 1101);
	9750	try expect(v[20] == 1102);
	9751	try expect(v[21] == 1103);
	9752	try expect(v[22] == 1104);
	9753	try expect(v[23] == 1105);
	9754	try expect(v[24] == 1106);
	9755	try expect(v[25] == 1107);
	9756	try expect(v[26] == 1108);
	9757	try expect(v[27] == 1109);
	9758	try expect(v[28] == 1110);
	9759	try expect(v[29] == 1111);
	9760	try expect(v[30] == 1112);
	9761	try expect(v[31] == 1113);
	9762	try expect(v[32] == 1114);
	9763	try expect(v[33] == 1115);
	9764	try expect(v[34] == 1116);
	9765	try expect(v[35] == 1117);
	9766	try expect(v[36] == 1118);
	9767	try expect(v[37] == 1119);
	9768	try expect(v[38] == 1120);
	9769	try expect(v[39] == 1121);
	9770	try expect(v[40] == 1122);
	9771	try expect(v[41] == 1123);
	9772	try expect(v[42] == 1124);
	9773	try expect(v[43] == 1125);
	9774	try expect(v[44] == 1126);
	9775	try expect(v[45] == 1127);
	9776	try expect(v[46] == 1128);
	9777	try expect(v[47] == 1129);
	9778	try expect(v[48] == 1130);
	9779	try expect(v[49] == 1131);
	9780	try expect(v[50] == 1132);
	9781	try expect(v[51] == 1133);
	9782	try expect(v[52] == 1134);
	9783	try expect(v[53] == 1135);
	9784	try expect(v[54] == 1136);
	9785	try expect(v[55] == 1137);
	9786	try expect(v[56] == 1138);
	9787	try expect(v[57] == 1139);
	9788	try expect(v[58] == 1140);
	9789	try expect(v[59] == 1141);
	9790	try expect(v[60] == 1142);
	9791	try expect(v[61] == 1143);
	9792	try expect(v[62] == 1144);
	9793	try expect(v[63] == 1145);
	9794	try expect(v[64] == 1146);
	9795	try expect(v[65] == 1147);
	9796	try expect(v[66] == 1148);
	9797	try expect(v[67] == 1149);
	9798	try expect(v[68] == 1150);
	9799	try expect(v[69] == 1151);
	9800	try expect(v[70] == 1152);
	9801	try expect(v[71] == 1153);
	9802	try expect(v[72] == 1154);
	9803	try expect(v[73] == 1155);
	9804	try expect(v[74] == 1156);
	9805	try expect(v[75] == 1157);
	9806	try expect(v[76] == 1158);
	9807	try expect(v[77] == 1159);
	9808	try expect(v[78] == 1160);
	9809	try expect(v[79] == 1161);
	9810	try expect(v[80] == 1162);
	9811	try expect(v[81] == 1163);
	9812	try expect(v[82] == 1164);
	9813	try expect(v[83] == 1165);
	9814	try expect(v[84] == 1166);
	9815	try expect(v[85] == 1167);
	9816	try expect(v[86] == 1168);
	9817	try expect(v[87] == 1169);
	9818	try expect(v[88] == 1170);
	9819	try expect(v[89] == 1171);
	9820	try expect(v[90] == 1172);
	9821	try expect(v[91] == 1173);
	9822	try expect(v[92] == 1174);
	9823	try expect(v[93] == 1175);
	9824	try expect(v[94] == 1176);
	9825	try expect(v[95] == 1177);
	9826	c_vector_96_u16(.{
	9827	1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193,
	9828	1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209,
	9829	1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225,
	9830	1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241,
	9831	1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257,
	9832	1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273,
	9833	}, 96);
	9834	c_test_vector_96_u16();
	9835	}
	9836
	9837	export fn zig_ret_vector_128_u16() @Vector(128, u16) {
	9838	return .{
	9839	1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289,
	9840	1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305,
	9841	1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321,
	9842	1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337,
	9843	1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353,
	9844	1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369,
	9845	1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385,
	9846	1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401,
	9847	};
	9848	}
	9849	export fn zig_vector_128_u16(v: @Vector(128, u16), i: usize) void {
	9850	expect(v[0] == 1402) catch @panic("test failure");
	9851	expect(v[1] == 1403) catch @panic("test failure");
	9852	expect(v[2] == 1404) catch @panic("test failure");
	9853	expect(v[3] == 1405) catch @panic("test failure");
	9854	expect(v[4] == 1406) catch @panic("test failure");
	9855	expect(v[5] == 1407) catch @panic("test failure");
	9856	expect(v[6] == 1408) catch @panic("test failure");
	9857	expect(v[7] == 1409) catch @panic("test failure");
	9858	expect(v[8] == 1410) catch @panic("test failure");
	9859	expect(v[9] == 1411) catch @panic("test failure");
	9860	expect(v[10] == 1412) catch @panic("test failure");
	9861	expect(v[11] == 1413) catch @panic("test failure");
	9862	expect(v[12] == 1414) catch @panic("test failure");
	9863	expect(v[13] == 1415) catch @panic("test failure");
	9864	expect(v[14] == 1416) catch @panic("test failure");
	9865	expect(v[15] == 1417) catch @panic("test failure");
	9866	expect(v[16] == 1418) catch @panic("test failure");
	9867	expect(v[17] == 1419) catch @panic("test failure");
	9868	expect(v[18] == 1420) catch @panic("test failure");
	9869	expect(v[19] == 1421) catch @panic("test failure");
	9870	expect(v[20] == 1422) catch @panic("test failure");
	9871	expect(v[21] == 1423) catch @panic("test failure");
	9872	expect(v[22] == 1424) catch @panic("test failure");
	9873	expect(v[23] == 1425) catch @panic("test failure");
	9874	expect(v[24] == 1426) catch @panic("test failure");
	9875	expect(v[25] == 1427) catch @panic("test failure");
	9876	expect(v[26] == 1428) catch @panic("test failure");
	9877	expect(v[27] == 1429) catch @panic("test failure");
	9878	expect(v[28] == 1430) catch @panic("test failure");
	9879	expect(v[29] == 1431) catch @panic("test failure");
	9880	expect(v[30] == 1432) catch @panic("test failure");
	9881	expect(v[31] == 1433) catch @panic("test failure");
	9882	expect(v[32] == 1434) catch @panic("test failure");
	9883	expect(v[33] == 1435) catch @panic("test failure");
	9884	expect(v[34] == 1436) catch @panic("test failure");
	9885	expect(v[35] == 1437) catch @panic("test failure");
	9886	expect(v[36] == 1438) catch @panic("test failure");
	9887	expect(v[37] == 1439) catch @panic("test failure");
	9888	expect(v[38] == 1440) catch @panic("test failure");
	9889	expect(v[39] == 1441) catch @panic("test failure");
	9890	expect(v[40] == 1442) catch @panic("test failure");
	9891	expect(v[41] == 1443) catch @panic("test failure");
	9892	expect(v[42] == 1444) catch @panic("test failure");
	9893	expect(v[43] == 1445) catch @panic("test failure");
	9894	expect(v[44] == 1446) catch @panic("test failure");
	9895	expect(v[45] == 1447) catch @panic("test failure");
	9896	expect(v[46] == 1448) catch @panic("test failure");
	9897	expect(v[47] == 1449) catch @panic("test failure");
	9898	expect(v[48] == 1450) catch @panic("test failure");
	9899	expect(v[49] == 1451) catch @panic("test failure");
	9900	expect(v[50] == 1452) catch @panic("test failure");
	9901	expect(v[51] == 1453) catch @panic("test failure");
	9902	expect(v[52] == 1454) catch @panic("test failure");
	9903	expect(v[53] == 1455) catch @panic("test failure");
	9904	expect(v[54] == 1456) catch @panic("test failure");
	9905	expect(v[55] == 1457) catch @panic("test failure");
	9906	expect(v[56] == 1458) catch @panic("test failure");
	9907	expect(v[57] == 1459) catch @panic("test failure");
	9908	expect(v[58] == 1460) catch @panic("test failure");
	9909	expect(v[59] == 1461) catch @panic("test failure");
	9910	expect(v[60] == 1462) catch @panic("test failure");
	9911	expect(v[61] == 1463) catch @panic("test failure");
	9912	expect(v[62] == 1464) catch @panic("test failure");
	9913	expect(v[63] == 1465) catch @panic("test failure");
	9914	expect(v[64] == 1466) catch @panic("test failure");
	9915	expect(v[65] == 1467) catch @panic("test failure");
	9916	expect(v[66] == 1468) catch @panic("test failure");
	9917	expect(v[67] == 1469) catch @panic("test failure");
	9918	expect(v[68] == 1470) catch @panic("test failure");
	9919	expect(v[69] == 1471) catch @panic("test failure");
	9920	expect(v[70] == 1472) catch @panic("test failure");
	9921	expect(v[71] == 1473) catch @panic("test failure");
	9922	expect(v[72] == 1474) catch @panic("test failure");
	9923	expect(v[73] == 1475) catch @panic("test failure");
	9924	expect(v[74] == 1476) catch @panic("test failure");
	9925	expect(v[75] == 1477) catch @panic("test failure");
	9926	expect(v[76] == 1478) catch @panic("test failure");
	9927	expect(v[77] == 1479) catch @panic("test failure");
	9928	expect(v[78] == 1480) catch @panic("test failure");
	9929	expect(v[79] == 1481) catch @panic("test failure");
	9930	expect(v[80] == 1482) catch @panic("test failure");
	9931	expect(v[81] == 1483) catch @panic("test failure");
	9932	expect(v[82] == 1484) catch @panic("test failure");
	9933	expect(v[83] == 1485) catch @panic("test failure");
	9934	expect(v[84] == 1486) catch @panic("test failure");
	9935	expect(v[85] == 1487) catch @panic("test failure");
	9936	expect(v[86] == 1488) catch @panic("test failure");
	9937	expect(v[87] == 1489) catch @panic("test failure");
	9938	expect(v[88] == 1490) catch @panic("test failure");
	9939	expect(v[89] == 1491) catch @panic("test failure");
	9940	expect(v[90] == 1492) catch @panic("test failure");
	9941	expect(v[91] == 1493) catch @panic("test failure");
	9942	expect(v[92] == 1494) catch @panic("test failure");
	9943	expect(v[93] == 1495) catch @panic("test failure");
	9944	expect(v[94] == 1496) catch @panic("test failure");
	9945	expect(v[95] == 1497) catch @panic("test failure");
	9946	expect(v[96] == 1498) catch @panic("test failure");
	9947	expect(v[97] == 1499) catch @panic("test failure");
	9948	expect(v[98] == 1500) catch @panic("test failure");
	9949	expect(v[99] == 1501) catch @panic("test failure");
	9950	expect(v[100] == 1502) catch @panic("test failure");
	9951	expect(v[101] == 1503) catch @panic("test failure");
	9952	expect(v[102] == 1504) catch @panic("test failure");
	9953	expect(v[103] == 1505) catch @panic("test failure");
	9954	expect(v[104] == 1506) catch @panic("test failure");
	9955	expect(v[105] == 1507) catch @panic("test failure");
	9956	expect(v[106] == 1508) catch @panic("test failure");
	9957	expect(v[107] == 1509) catch @panic("test failure");
	9958	expect(v[108] == 1510) catch @panic("test failure");
	9959	expect(v[109] == 1511) catch @panic("test failure");
	9960	expect(v[110] == 1512) catch @panic("test failure");
	9961	expect(v[111] == 1513) catch @panic("test failure");
	9962	expect(v[112] == 1514) catch @panic("test failure");
	9963	expect(v[113] == 1515) catch @panic("test failure");
	9964	expect(v[114] == 1516) catch @panic("test failure");
	9965	expect(v[115] == 1517) catch @panic("test failure");
	9966	expect(v[116] == 1518) catch @panic("test failure");
	9967	expect(v[117] == 1519) catch @panic("test failure");
	9968	expect(v[118] == 1520) catch @panic("test failure");
	9969	expect(v[119] == 1521) catch @panic("test failure");
	9970	expect(v[120] == 1522) catch @panic("test failure");
	9971	expect(v[121] == 1523) catch @panic("test failure");
	9972	expect(v[122] == 1524) catch @panic("test failure");
	9973	expect(v[123] == 1525) catch @panic("test failure");
	9974	expect(v[124] == 1526) catch @panic("test failure");
	9975	expect(v[125] == 1527) catch @panic("test failure");
	9976	expect(v[126] == 1528) catch @panic("test failure");
	9977	expect(v[127] == 1529) catch @panic("test failure");
	9978	expect(i == 128) catch @panic("test failure");
	9979	}
	9980
	9981	extern fn c_ret_vector_128_u16() @Vector(128, u16);
	9982	extern fn c_vector_128_u16(@Vector(128, u16), usize) void;
	9983	extern fn c_test_vector_128_u16() void;
	9984
	9985	test "@Vector(128, u16)" {
	9986	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	9987	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	9988	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	9989	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	9990	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	9991
	9992	const v = c_ret_vector_128_u16();
	9993	try expect(v[0] == 1530);
	9994	try expect(v[1] == 1531);
	9995	try expect(v[2] == 1532);
	9996	try expect(v[3] == 1533);
	9997	try expect(v[4] == 1534);
	9998	try expect(v[5] == 1535);
	9999	try expect(v[6] == 1536);
	10000	try expect(v[7] == 1537);
	10001	try expect(v[8] == 1538);
	10002	try expect(v[9] == 1539);
	10003	try expect(v[10] == 1540);
	10004	try expect(v[11] == 1541);
	10005	try expect(v[12] == 1542);
	10006	try expect(v[13] == 1543);
	10007	try expect(v[14] == 1544);
	10008	try expect(v[15] == 1545);
	10009	try expect(v[16] == 1546);
	10010	try expect(v[17] == 1547);
	10011	try expect(v[18] == 1548);
	10012	try expect(v[19] == 1549);
	10013	try expect(v[20] == 1550);
	10014	try expect(v[21] == 1551);
	10015	try expect(v[22] == 1552);
	10016	try expect(v[23] == 1553);
	10017	try expect(v[24] == 1554);
	10018	try expect(v[25] == 1555);
	10019	try expect(v[26] == 1556);
	10020	try expect(v[27] == 1557);
	10021	try expect(v[28] == 1558);
	10022	try expect(v[29] == 1559);
	10023	try expect(v[30] == 1560);
	10024	try expect(v[31] == 1561);
	10025	try expect(v[32] == 1562);
	10026	try expect(v[33] == 1563);
	10027	try expect(v[34] == 1564);
	10028	try expect(v[35] == 1565);
	10029	try expect(v[36] == 1566);
	10030	try expect(v[37] == 1567);
	10031	try expect(v[38] == 1568);
	10032	try expect(v[39] == 1569);
	10033	try expect(v[40] == 1570);
	10034	try expect(v[41] == 1571);
	10035	try expect(v[42] == 1572);
	10036	try expect(v[43] == 1573);
	10037	try expect(v[44] == 1574);
	10038	try expect(v[45] == 1575);
	10039	try expect(v[46] == 1576);
	10040	try expect(v[47] == 1577);
	10041	try expect(v[48] == 1578);
	10042	try expect(v[49] == 1579);
	10043	try expect(v[50] == 1580);
	10044	try expect(v[51] == 1581);
	10045	try expect(v[52] == 1582);
	10046	try expect(v[53] == 1583);
	10047	try expect(v[54] == 1584);
	10048	try expect(v[55] == 1585);
	10049	try expect(v[56] == 1586);
	10050	try expect(v[57] == 1587);
	10051	try expect(v[58] == 1588);
	10052	try expect(v[59] == 1589);
	10053	try expect(v[60] == 1590);
	10054	try expect(v[61] == 1591);
	10055	try expect(v[62] == 1592);
	10056	try expect(v[63] == 1593);
	10057	try expect(v[64] == 1594);
	10058	try expect(v[65] == 1595);
	10059	try expect(v[66] == 1596);
	10060	try expect(v[67] == 1597);
	10061	try expect(v[68] == 1598);
	10062	try expect(v[69] == 1599);
	10063	try expect(v[70] == 1600);
	10064	try expect(v[71] == 1601);
	10065	try expect(v[72] == 1602);
	10066	try expect(v[73] == 1603);
	10067	try expect(v[74] == 1604);
	10068	try expect(v[75] == 1605);
	10069	try expect(v[76] == 1606);
	10070	try expect(v[77] == 1607);
	10071	try expect(v[78] == 1608);
	10072	try expect(v[79] == 1609);
	10073	try expect(v[80] == 1610);
	10074	try expect(v[81] == 1611);
	10075	try expect(v[82] == 1612);
	10076	try expect(v[83] == 1613);
	10077	try expect(v[84] == 1614);
	10078	try expect(v[85] == 1615);
	10079	try expect(v[86] == 1616);
	10080	try expect(v[87] == 1617);
	10081	try expect(v[88] == 1618);
	10082	try expect(v[89] == 1619);
	10083	try expect(v[90] == 1620);
	10084	try expect(v[91] == 1621);
	10085	try expect(v[92] == 1622);
	10086	try expect(v[93] == 1623);
	10087	try expect(v[94] == 1624);
	10088	try expect(v[95] == 1625);
	10089	try expect(v[96] == 1626);
	10090	try expect(v[97] == 1627);
	10091	try expect(v[98] == 1628);
	10092	try expect(v[99] == 1629);
	10093	try expect(v[100] == 1630);
	10094	try expect(v[101] == 1631);
	10095	try expect(v[102] == 1632);
	10096	try expect(v[103] == 1633);
	10097	try expect(v[104] == 1634);
	10098	try expect(v[105] == 1635);
	10099	try expect(v[106] == 1636);
	10100	try expect(v[107] == 1637);
	10101	try expect(v[108] == 1638);
	10102	try expect(v[109] == 1639);
	10103	try expect(v[110] == 1640);
	10104	try expect(v[111] == 1641);
	10105	try expect(v[112] == 1642);
	10106	try expect(v[113] == 1643);
	10107	try expect(v[114] == 1644);
	10108	try expect(v[115] == 1645);
	10109	try expect(v[116] == 1646);
	10110	try expect(v[117] == 1647);
	10111	try expect(v[118] == 1648);
	10112	try expect(v[119] == 1649);
	10113	try expect(v[120] == 1650);
	10114	try expect(v[121] == 1651);
	10115	try expect(v[122] == 1652);
	10116	try expect(v[123] == 1653);
	10117	try expect(v[124] == 1654);
	10118	try expect(v[125] == 1655);
	10119	try expect(v[126] == 1656);
	10120	try expect(v[127] == 1657);
	10121	c_vector_128_u16(.{
	10122	1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673,
	10123	1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689,
	10124	1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705,
	10125	1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721,
	10126	1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737,
	10127	1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753,
	10128	1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769,
	10129	1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785,
	10130	}, 128);
	10131	c_test_vector_128_u16();
	10132	}
	10133
	10134	export fn zig_ret_vector_192_u16() @Vector(192, u16) {
	10135	return .{
	10136	1786, 1787, 1788, 1789, 1790, 1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 1799, 1800, 1801,
	10137	1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817,
	10138	1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833,
	10139	1834, 1835, 1836, 1837, 1838, 1839, 1840, 1841, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849,
	10140	1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865,
	10141	1866, 1867, 1868, 1869, 1870, 1871, 1872, 1873, 1874, 1875, 1876, 1877, 1878, 1879, 1880, 1881,
	10142	1882, 1883, 1884, 1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 1893, 1894, 1895, 1896, 1897,
	10143	1898, 1899, 1900, 1901, 1902, 1903, 1904, 1905, 1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913,
	10144	1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 1922, 1923, 1924, 1925, 1926, 1927, 1928, 1929,
	10145	1930, 1931, 1932, 1933, 1934, 1935, 1936, 1937, 1938, 1939, 1940, 1941, 1942, 1943, 1944, 1945,
	10146	1946, 1947, 1948, 1949, 1950, 1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 1959, 1960, 1961,
	10147	1962, 1963, 1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 1972, 1973, 1974, 1975, 1976, 1977,
	10148	};
	10149	}
	10150	export fn zig_vector_192_u16(v: @Vector(192, u16), i: usize) void {
	10151	expect(v[0] == 1978) catch @panic("test failure");
	10152	expect(v[1] == 1979) catch @panic("test failure");
	10153	expect(v[2] == 1980) catch @panic("test failure");
	10154	expect(v[3] == 1981) catch @panic("test failure");
	10155	expect(v[4] == 1982) catch @panic("test failure");
	10156	expect(v[5] == 1983) catch @panic("test failure");
	10157	expect(v[6] == 1984) catch @panic("test failure");
	10158	expect(v[7] == 1985) catch @panic("test failure");
	10159	expect(v[8] == 1986) catch @panic("test failure");
	10160	expect(v[9] == 1987) catch @panic("test failure");
	10161	expect(v[10] == 1988) catch @panic("test failure");
	10162	expect(v[11] == 1989) catch @panic("test failure");
	10163	expect(v[12] == 1990) catch @panic("test failure");
	10164	expect(v[13] == 1991) catch @panic("test failure");
	10165	expect(v[14] == 1992) catch @panic("test failure");
	10166	expect(v[15] == 1993) catch @panic("test failure");
	10167	expect(v[16] == 1994) catch @panic("test failure");
	10168	expect(v[17] == 1995) catch @panic("test failure");
	10169	expect(v[18] == 1996) catch @panic("test failure");
	10170	expect(v[19] == 1997) catch @panic("test failure");
	10171	expect(v[20] == 1998) catch @panic("test failure");
	10172	expect(v[21] == 1999) catch @panic("test failure");
	10173	expect(v[22] == 2000) catch @panic("test failure");
	10174	expect(v[23] == 2001) catch @panic("test failure");
	10175	expect(v[24] == 2002) catch @panic("test failure");
	10176	expect(v[25] == 2003) catch @panic("test failure");
	10177	expect(v[26] == 2004) catch @panic("test failure");
	10178	expect(v[27] == 2005) catch @panic("test failure");
	10179	expect(v[28] == 2006) catch @panic("test failure");
	10180	expect(v[29] == 2007) catch @panic("test failure");
	10181	expect(v[30] == 2008) catch @panic("test failure");
	10182	expect(v[31] == 2009) catch @panic("test failure");
	10183	expect(v[32] == 2010) catch @panic("test failure");
	10184	expect(v[33] == 2011) catch @panic("test failure");
	10185	expect(v[34] == 2012) catch @panic("test failure");
	10186	expect(v[35] == 2013) catch @panic("test failure");
	10187	expect(v[36] == 2014) catch @panic("test failure");
	10188	expect(v[37] == 2015) catch @panic("test failure");
	10189	expect(v[38] == 2016) catch @panic("test failure");
	10190	expect(v[39] == 2017) catch @panic("test failure");
	10191	expect(v[40] == 2018) catch @panic("test failure");
	10192	expect(v[41] == 2019) catch @panic("test failure");
	10193	expect(v[42] == 2020) catch @panic("test failure");
	10194	expect(v[43] == 2021) catch @panic("test failure");
	10195	expect(v[44] == 2022) catch @panic("test failure");
	10196	expect(v[45] == 2023) catch @panic("test failure");
	10197	expect(v[46] == 2024) catch @panic("test failure");
	10198	expect(v[47] == 2025) catch @panic("test failure");
	10199	expect(v[48] == 2026) catch @panic("test failure");
	10200	expect(v[49] == 2027) catch @panic("test failure");
	10201	expect(v[50] == 2028) catch @panic("test failure");
	10202	expect(v[51] == 2029) catch @panic("test failure");
	10203	expect(v[52] == 2030) catch @panic("test failure");
	10204	expect(v[53] == 2031) catch @panic("test failure");
	10205	expect(v[54] == 2032) catch @panic("test failure");
	10206	expect(v[55] == 2033) catch @panic("test failure");
	10207	expect(v[56] == 2034) catch @panic("test failure");
	10208	expect(v[57] == 2035) catch @panic("test failure");
	10209	expect(v[58] == 2036) catch @panic("test failure");
	10210	expect(v[59] == 2037) catch @panic("test failure");
	10211	expect(v[60] == 2038) catch @panic("test failure");
	10212	expect(v[61] == 2039) catch @panic("test failure");
	10213	expect(v[62] == 2040) catch @panic("test failure");
	10214	expect(v[63] == 2041) catch @panic("test failure");
	10215	expect(v[64] == 2042) catch @panic("test failure");
	10216	expect(v[65] == 2043) catch @panic("test failure");
	10217	expect(v[66] == 2044) catch @panic("test failure");
	10218	expect(v[67] == 2045) catch @panic("test failure");
	10219	expect(v[68] == 2046) catch @panic("test failure");
	10220	expect(v[69] == 2047) catch @panic("test failure");
	10221	expect(v[70] == 2048) catch @panic("test failure");
	10222	expect(v[71] == 2049) catch @panic("test failure");
	10223	expect(v[72] == 2050) catch @panic("test failure");
	10224	expect(v[73] == 2051) catch @panic("test failure");
	10225	expect(v[74] == 2052) catch @panic("test failure");
	10226	expect(v[75] == 2053) catch @panic("test failure");
	10227	expect(v[76] == 2054) catch @panic("test failure");
	10228	expect(v[77] == 2055) catch @panic("test failure");
	10229	expect(v[78] == 2056) catch @panic("test failure");
	10230	expect(v[79] == 2057) catch @panic("test failure");
	10231	expect(v[80] == 2058) catch @panic("test failure");
	10232	expect(v[81] == 2059) catch @panic("test failure");
	10233	expect(v[82] == 2060) catch @panic("test failure");
	10234	expect(v[83] == 2061) catch @panic("test failure");
	10235	expect(v[84] == 2062) catch @panic("test failure");
	10236	expect(v[85] == 2063) catch @panic("test failure");
	10237	expect(v[86] == 2064) catch @panic("test failure");
	10238	expect(v[87] == 2065) catch @panic("test failure");
	10239	expect(v[88] == 2066) catch @panic("test failure");
	10240	expect(v[89] == 2067) catch @panic("test failure");
	10241	expect(v[90] == 2068) catch @panic("test failure");
	10242	expect(v[91] == 2069) catch @panic("test failure");
	10243	expect(v[92] == 2070) catch @panic("test failure");
	10244	expect(v[93] == 2071) catch @panic("test failure");
	10245	expect(v[94] == 2072) catch @panic("test failure");
	10246	expect(v[95] == 2073) catch @panic("test failure");
	10247	expect(v[96] == 2074) catch @panic("test failure");
	10248	expect(v[97] == 2075) catch @panic("test failure");
	10249	expect(v[98] == 2076) catch @panic("test failure");
	10250	expect(v[99] == 2077) catch @panic("test failure");
	10251	expect(v[100] == 2078) catch @panic("test failure");
	10252	expect(v[101] == 2079) catch @panic("test failure");
	10253	expect(v[102] == 2080) catch @panic("test failure");
	10254	expect(v[103] == 2081) catch @panic("test failure");
	10255	expect(v[104] == 2082) catch @panic("test failure");
	10256	expect(v[105] == 2083) catch @panic("test failure");
	10257	expect(v[106] == 2084) catch @panic("test failure");
	10258	expect(v[107] == 2085) catch @panic("test failure");
	10259	expect(v[108] == 2086) catch @panic("test failure");
	10260	expect(v[109] == 2087) catch @panic("test failure");
	10261	expect(v[110] == 2088) catch @panic("test failure");
	10262	expect(v[111] == 2089) catch @panic("test failure");
	10263	expect(v[112] == 2090) catch @panic("test failure");
	10264	expect(v[113] == 2091) catch @panic("test failure");
	10265	expect(v[114] == 2092) catch @panic("test failure");
	10266	expect(v[115] == 2093) catch @panic("test failure");
	10267	expect(v[116] == 2094) catch @panic("test failure");
	10268	expect(v[117] == 2095) catch @panic("test failure");
	10269	expect(v[118] == 2096) catch @panic("test failure");
	10270	expect(v[119] == 2097) catch @panic("test failure");
	10271	expect(v[120] == 2098) catch @panic("test failure");
	10272	expect(v[121] == 2099) catch @panic("test failure");
	10273	expect(v[122] == 2100) catch @panic("test failure");
	10274	expect(v[123] == 2101) catch @panic("test failure");
	10275	expect(v[124] == 2102) catch @panic("test failure");
	10276	expect(v[125] == 2103) catch @panic("test failure");
	10277	expect(v[126] == 2104) catch @panic("test failure");
	10278	expect(v[127] == 2105) catch @panic("test failure");
	10279	expect(v[128] == 2106) catch @panic("test failure");
	10280	expect(v[129] == 2107) catch @panic("test failure");
	10281	expect(v[130] == 2108) catch @panic("test failure");
	10282	expect(v[131] == 2109) catch @panic("test failure");
	10283	expect(v[132] == 2110) catch @panic("test failure");
	10284	expect(v[133] == 2111) catch @panic("test failure");
	10285	expect(v[134] == 2112) catch @panic("test failure");
	10286	expect(v[135] == 2113) catch @panic("test failure");
	10287	expect(v[136] == 2114) catch @panic("test failure");
	10288	expect(v[137] == 2115) catch @panic("test failure");
	10289	expect(v[138] == 2116) catch @panic("test failure");
	10290	expect(v[139] == 2117) catch @panic("test failure");
	10291	expect(v[140] == 2118) catch @panic("test failure");
	10292	expect(v[141] == 2119) catch @panic("test failure");
	10293	expect(v[142] == 2120) catch @panic("test failure");
	10294	expect(v[143] == 2121) catch @panic("test failure");
	10295	expect(v[144] == 2122) catch @panic("test failure");
	10296	expect(v[145] == 2123) catch @panic("test failure");
	10297	expect(v[146] == 2124) catch @panic("test failure");
	10298	expect(v[147] == 2125) catch @panic("test failure");
	10299	expect(v[148] == 2126) catch @panic("test failure");
	10300	expect(v[149] == 2127) catch @panic("test failure");
	10301	expect(v[150] == 2128) catch @panic("test failure");
	10302	expect(v[151] == 2129) catch @panic("test failure");
	10303	expect(v[152] == 2130) catch @panic("test failure");
	10304	expect(v[153] == 2131) catch @panic("test failure");
	10305	expect(v[154] == 2132) catch @panic("test failure");
	10306	expect(v[155] == 2133) catch @panic("test failure");
	10307	expect(v[156] == 2134) catch @panic("test failure");
	10308	expect(v[157] == 2135) catch @panic("test failure");
	10309	expect(v[158] == 2136) catch @panic("test failure");
	10310	expect(v[159] == 2137) catch @panic("test failure");
	10311	expect(v[160] == 2138) catch @panic("test failure");
	10312	expect(v[161] == 2139) catch @panic("test failure");
	10313	expect(v[162] == 2140) catch @panic("test failure");
	10314	expect(v[163] == 2141) catch @panic("test failure");
	10315	expect(v[164] == 2142) catch @panic("test failure");
	10316	expect(v[165] == 2143) catch @panic("test failure");
	10317	expect(v[166] == 2144) catch @panic("test failure");
	10318	expect(v[167] == 2145) catch @panic("test failure");
	10319	expect(v[168] == 2146) catch @panic("test failure");
	10320	expect(v[169] == 2147) catch @panic("test failure");
	10321	expect(v[170] == 2148) catch @panic("test failure");
	10322	expect(v[171] == 2149) catch @panic("test failure");
	10323	expect(v[172] == 2150) catch @panic("test failure");
	10324	expect(v[173] == 2151) catch @panic("test failure");
	10325	expect(v[174] == 2152) catch @panic("test failure");
	10326	expect(v[175] == 2153) catch @panic("test failure");
	10327	expect(v[176] == 2154) catch @panic("test failure");
	10328	expect(v[177] == 2155) catch @panic("test failure");
	10329	expect(v[178] == 2156) catch @panic("test failure");
	10330	expect(v[179] == 2157) catch @panic("test failure");
	10331	expect(v[180] == 2158) catch @panic("test failure");
	10332	expect(v[181] == 2159) catch @panic("test failure");
	10333	expect(v[182] == 2160) catch @panic("test failure");
	10334	expect(v[183] == 2161) catch @panic("test failure");
	10335	expect(v[184] == 2162) catch @panic("test failure");
	10336	expect(v[185] == 2163) catch @panic("test failure");
	10337	expect(v[186] == 2164) catch @panic("test failure");
	10338	expect(v[187] == 2165) catch @panic("test failure");
	10339	expect(v[188] == 2166) catch @panic("test failure");
	10340	expect(v[189] == 2167) catch @panic("test failure");
	10341	expect(v[190] == 2168) catch @panic("test failure");
	10342	expect(v[191] == 2169) catch @panic("test failure");
	10343	expect(i == 192) catch @panic("test failure");
	10344	}
	10345
	10346	extern fn c_ret_vector_192_u16() @Vector(192, u16);
	10347	extern fn c_vector_192_u16(@Vector(192, u16), usize) void;
	10348	extern fn c_test_vector_192_u16() void;
	10349
	10350	test "@Vector(192, u16)" {
	10351	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	10352	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	10353	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	10354	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	10355	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	10356
	10357	const v = c_ret_vector_192_u16();
	10358	try expect(v[0] == 2170);
	10359	try expect(v[1] == 2171);
	10360	try expect(v[2] == 2172);
	10361	try expect(v[3] == 2173);
	10362	try expect(v[4] == 2174);
	10363	try expect(v[5] == 2175);
	10364	try expect(v[6] == 2176);
	10365	try expect(v[7] == 2177);
	10366	try expect(v[8] == 2178);
	10367	try expect(v[9] == 2179);
	10368	try expect(v[10] == 2180);
	10369	try expect(v[11] == 2181);
	10370	try expect(v[12] == 2182);
	10371	try expect(v[13] == 2183);
	10372	try expect(v[14] == 2184);
	10373	try expect(v[15] == 2185);
	10374	try expect(v[16] == 2186);
	10375	try expect(v[17] == 2187);
	10376	try expect(v[18] == 2188);
	10377	try expect(v[19] == 2189);
	10378	try expect(v[20] == 2190);
	10379	try expect(v[21] == 2191);
	10380	try expect(v[22] == 2192);
	10381	try expect(v[23] == 2193);
	10382	try expect(v[24] == 2194);
	10383	try expect(v[25] == 2195);
	10384	try expect(v[26] == 2196);
	10385	try expect(v[27] == 2197);
	10386	try expect(v[28] == 2198);
	10387	try expect(v[29] == 2199);
	10388	try expect(v[30] == 2200);
	10389	try expect(v[31] == 2201);
	10390	try expect(v[32] == 2202);
	10391	try expect(v[33] == 2203);
	10392	try expect(v[34] == 2204);
	10393	try expect(v[35] == 2205);
	10394	try expect(v[36] == 2206);
	10395	try expect(v[37] == 2207);
	10396	try expect(v[38] == 2208);
	10397	try expect(v[39] == 2209);
	10398	try expect(v[40] == 2210);
	10399	try expect(v[41] == 2211);
	10400	try expect(v[42] == 2212);
	10401	try expect(v[43] == 2213);
	10402	try expect(v[44] == 2214);
	10403	try expect(v[45] == 2215);
	10404	try expect(v[46] == 2216);
	10405	try expect(v[47] == 2217);
	10406	try expect(v[48] == 2218);
	10407	try expect(v[49] == 2219);
	10408	try expect(v[50] == 2220);
	10409	try expect(v[51] == 2221);
	10410	try expect(v[52] == 2222);
	10411	try expect(v[53] == 2223);
	10412	try expect(v[54] == 2224);
	10413	try expect(v[55] == 2225);
	10414	try expect(v[56] == 2226);
	10415	try expect(v[57] == 2227);
	10416	try expect(v[58] == 2228);
	10417	try expect(v[59] == 2229);
	10418	try expect(v[60] == 2230);
	10419	try expect(v[61] == 2231);
	10420	try expect(v[62] == 2232);
	10421	try expect(v[63] == 2233);
	10422	try expect(v[64] == 2234);
	10423	try expect(v[65] == 2235);
	10424	try expect(v[66] == 2236);
	10425	try expect(v[67] == 2237);
	10426	try expect(v[68] == 2238);
	10427	try expect(v[69] == 2239);
	10428	try expect(v[70] == 2240);
	10429	try expect(v[71] == 2241);
	10430	try expect(v[72] == 2242);
	10431	try expect(v[73] == 2243);
	10432	try expect(v[74] == 2244);
	10433	try expect(v[75] == 2245);
	10434	try expect(v[76] == 2246);
	10435	try expect(v[77] == 2247);
	10436	try expect(v[78] == 2248);
	10437	try expect(v[79] == 2249);
	10438	try expect(v[80] == 2250);
	10439	try expect(v[81] == 2251);
	10440	try expect(v[82] == 2252);
	10441	try expect(v[83] == 2253);
	10442	try expect(v[84] == 2254);
	10443	try expect(v[85] == 2255);
	10444	try expect(v[86] == 2256);
	10445	try expect(v[87] == 2257);
	10446	try expect(v[88] == 2258);
	10447	try expect(v[89] == 2259);
	10448	try expect(v[90] == 2260);
	10449	try expect(v[91] == 2261);
	10450	try expect(v[92] == 2262);
	10451	try expect(v[93] == 2263);
	10452	try expect(v[94] == 2264);
	10453	try expect(v[95] == 2265);
	10454	try expect(v[96] == 2266);
	10455	try expect(v[97] == 2267);
	10456	try expect(v[98] == 2268);
	10457	try expect(v[99] == 2269);
	10458	try expect(v[100] == 2270);
	10459	try expect(v[101] == 2271);
	10460	try expect(v[102] == 2272);
	10461	try expect(v[103] == 2273);
	10462	try expect(v[104] == 2274);
	10463	try expect(v[105] == 2275);
	10464	try expect(v[106] == 2276);
	10465	try expect(v[107] == 2277);
	10466	try expect(v[108] == 2278);
	10467	try expect(v[109] == 2279);
	10468	try expect(v[110] == 2280);
	10469	try expect(v[111] == 2281);
	10470	try expect(v[112] == 2282);
	10471	try expect(v[113] == 2283);
	10472	try expect(v[114] == 2284);
	10473	try expect(v[115] == 2285);
	10474	try expect(v[116] == 2286);
	10475	try expect(v[117] == 2287);
	10476	try expect(v[118] == 2288);
	10477	try expect(v[119] == 2289);
	10478	try expect(v[120] == 2290);
	10479	try expect(v[121] == 2291);
	10480	try expect(v[122] == 2292);
	10481	try expect(v[123] == 2293);
	10482	try expect(v[124] == 2294);
	10483	try expect(v[125] == 2295);
	10484	try expect(v[126] == 2296);
	10485	try expect(v[127] == 2297);
	10486	try expect(v[128] == 2298);
	10487	try expect(v[129] == 2299);
	10488	try expect(v[130] == 2300);
	10489	try expect(v[131] == 2301);
	10490	try expect(v[132] == 2302);
	10491	try expect(v[133] == 2303);
	10492	try expect(v[134] == 2304);
	10493	try expect(v[135] == 2305);
	10494	try expect(v[136] == 2306);
	10495	try expect(v[137] == 2307);
	10496	try expect(v[138] == 2308);
	10497	try expect(v[139] == 2309);
	10498	try expect(v[140] == 2310);
	10499	try expect(v[141] == 2311);
	10500	try expect(v[142] == 2312);
	10501	try expect(v[143] == 2313);
	10502	try expect(v[144] == 2314);
	10503	try expect(v[145] == 2315);
	10504	try expect(v[146] == 2316);
	10505	try expect(v[147] == 2317);
	10506	try expect(v[148] == 2318);
	10507	try expect(v[149] == 2319);
	10508	try expect(v[150] == 2320);
	10509	try expect(v[151] == 2321);
	10510	try expect(v[152] == 2322);
	10511	try expect(v[153] == 2323);
	10512	try expect(v[154] == 2324);
	10513	try expect(v[155] == 2325);
	10514	try expect(v[156] == 2326);
	10515	try expect(v[157] == 2327);
	10516	try expect(v[158] == 2328);
	10517	try expect(v[159] == 2329);
	10518	try expect(v[160] == 2330);
	10519	try expect(v[161] == 2331);
	10520	try expect(v[162] == 2332);
	10521	try expect(v[163] == 2333);
	10522	try expect(v[164] == 2334);
	10523	try expect(v[165] == 2335);
	10524	try expect(v[166] == 2336);
	10525	try expect(v[167] == 2337);
	10526	try expect(v[168] == 2338);
	10527	try expect(v[169] == 2339);
	10528	try expect(v[170] == 2340);
	10529	try expect(v[171] == 2341);
	10530	try expect(v[172] == 2342);
	10531	try expect(v[173] == 2343);
	10532	try expect(v[174] == 2344);
	10533	try expect(v[175] == 2345);
	10534	try expect(v[176] == 2346);
	10535	try expect(v[177] == 2347);
	10536	try expect(v[178] == 2348);
	10537	try expect(v[179] == 2349);
	10538	try expect(v[180] == 2350);
	10539	try expect(v[181] == 2351);
	10540	try expect(v[182] == 2352);
	10541	try expect(v[183] == 2353);
	10542	try expect(v[184] == 2354);
	10543	try expect(v[185] == 2355);
	10544	try expect(v[186] == 2356);
	10545	try expect(v[187] == 2357);
	10546	try expect(v[188] == 2358);
	10547	try expect(v[189] == 2359);
	10548	try expect(v[190] == 2360);
	10549	try expect(v[191] == 2361);
	10550	c_vector_192_u16(.{
	10551	2362, 2363, 2364, 2365, 2366, 2367, 2368, 2369, 2370, 2371, 2372, 2373, 2374, 2375, 2376, 2377,
	10552	2378, 2379, 2380, 2381, 2382, 2383, 2384, 2385, 2386, 2387, 2388, 2389, 2390, 2391, 2392, 2393,
	10553	2394, 2395, 2396, 2397, 2398, 2399, 2400, 2401, 2402, 2403, 2404, 2405, 2406, 2407, 2408, 2409,
	10554	2410, 2411, 2412, 2413, 2414, 2415, 2416, 2417, 2418, 2419, 2420, 2421, 2422, 2423, 2424, 2425,
	10555	2426, 2427, 2428, 2429, 2430, 2431, 2432, 2433, 2434, 2435, 2436, 2437, 2438, 2439, 2440, 2441,
	10556	2442, 2443, 2444, 2445, 2446, 2447, 2448, 2449, 2450, 2451, 2452, 2453, 2454, 2455, 2456, 2457,
	10557	2458, 2459, 2460, 2461, 2462, 2463, 2464, 2465, 2466, 2467, 2468, 2469, 2470, 2471, 2472, 2473,
	10558	2474, 2475, 2476, 2477, 2478, 2479, 2480, 2481, 2482, 2483, 2484, 2485, 2486, 2487, 2488, 2489,
	10559	2490, 2491, 2492, 2493, 2494, 2495, 2496, 2497, 2498, 2499, 2500, 2501, 2502, 2503, 2504, 2505,
	10560	2506, 2507, 2508, 2509, 2510, 2511, 2512, 2513, 2514, 2515, 2516, 2517, 2518, 2519, 2520, 2521,
	10561	2522, 2523, 2524, 2525, 2526, 2527, 2528, 2529, 2530, 2531, 2532, 2533, 2534, 2535, 2536, 2537,
	10562	2538, 2539, 2540, 2541, 2542, 2543, 2544, 2545, 2546, 2547, 2548, 2549, 2550, 2551, 2552, 2553,
	10563	}, 192);
	10564	c_test_vector_192_u16();
	10565	}
	10566
	10567	export fn zig_ret_vector_256_u16() @Vector(256, u16) {
	10568	return .{
	10569	2554, 2555, 2556, 2557, 2558, 2559, 2560, 2561, 2562, 2563, 2564, 2565, 2566, 2567, 2568, 2569,
	10570	2570, 2571, 2572, 2573, 2574, 2575, 2576, 2577, 2578, 2579, 2580, 2581, 2582, 2583, 2584, 2585,
	10571	2586, 2587, 2588, 2589, 2590, 2591, 2592, 2593, 2594, 2595, 2596, 2597, 2598, 2599, 2600, 2601,
	10572	2602, 2603, 2604, 2605, 2606, 2607, 2608, 2609, 2610, 2611, 2612, 2613, 2614, 2615, 2616, 2617,
	10573	2618, 2619, 2620, 2621, 2622, 2623, 2624, 2625, 2626, 2627, 2628, 2629, 2630, 2631, 2632, 2633,
	10574	2634, 2635, 2636, 2637, 2638, 2639, 2640, 2641, 2642, 2643, 2644, 2645, 2646, 2647, 2648, 2649,
	10575	2650, 2651, 2652, 2653, 2654, 2655, 2656, 2657, 2658, 2659, 2660, 2661, 2662, 2663, 2664, 2665,
	10576	2666, 2667, 2668, 2669, 2670, 2671, 2672, 2673, 2674, 2675, 2676, 2677, 2678, 2679, 2680, 2681,
	10577	2682, 2683, 2684, 2685, 2686, 2687, 2688, 2689, 2690, 2691, 2692, 2693, 2694, 2695, 2696, 2697,
	10578	2698, 2699, 2700, 2701, 2702, 2703, 2704, 2705, 2706, 2707, 2708, 2709, 2710, 2711, 2712, 2713,
	10579	2714, 2715, 2716, 2717, 2718, 2719, 2720, 2721, 2722, 2723, 2724, 2725, 2726, 2727, 2728, 2729,
	10580	2730, 2731, 2732, 2733, 2734, 2735, 2736, 2737, 2738, 2739, 2740, 2741, 2742, 2743, 2744, 2745,
	10581	2746, 2747, 2748, 2749, 2750, 2751, 2752, 2753, 2754, 2755, 2756, 2757, 2758, 2759, 2760, 2761,
	10582	2762, 2763, 2764, 2765, 2766, 2767, 2768, 2769, 2770, 2771, 2772, 2773, 2774, 2775, 2776, 2777,
	10583	2778, 2779, 2780, 2781, 2782, 2783, 2784, 2785, 2786, 2787, 2788, 2789, 2790, 2791, 2792, 2793,
	10584	2794, 2795, 2796, 2797, 2798, 2799, 2800, 2801, 2802, 2803, 2804, 2805, 2806, 2807, 2808, 2809,
	10585	};
	10586	}
	10587	export fn zig_vector_256_u16(v: @Vector(256, u16), i: usize) void {
	10588	expect(v[0] == 2810) catch @panic("test failure");
	10589	expect(v[1] == 2811) catch @panic("test failure");
	10590	expect(v[2] == 2812) catch @panic("test failure");
	10591	expect(v[3] == 2813) catch @panic("test failure");
	10592	expect(v[4] == 2814) catch @panic("test failure");
	10593	expect(v[5] == 2815) catch @panic("test failure");
	10594	expect(v[6] == 2816) catch @panic("test failure");
	10595	expect(v[7] == 2817) catch @panic("test failure");
	10596	expect(v[8] == 2818) catch @panic("test failure");
	10597	expect(v[9] == 2819) catch @panic("test failure");
	10598	expect(v[10] == 2820) catch @panic("test failure");
	10599	expect(v[11] == 2821) catch @panic("test failure");
	10600	expect(v[12] == 2822) catch @panic("test failure");
	10601	expect(v[13] == 2823) catch @panic("test failure");
	10602	expect(v[14] == 2824) catch @panic("test failure");
	10603	expect(v[15] == 2825) catch @panic("test failure");
	10604	expect(v[16] == 2826) catch @panic("test failure");
	10605	expect(v[17] == 2827) catch @panic("test failure");
	10606	expect(v[18] == 2828) catch @panic("test failure");
	10607	expect(v[19] == 2829) catch @panic("test failure");
	10608	expect(v[20] == 2830) catch @panic("test failure");
	10609	expect(v[21] == 2831) catch @panic("test failure");
	10610	expect(v[22] == 2832) catch @panic("test failure");
	10611	expect(v[23] == 2833) catch @panic("test failure");
	10612	expect(v[24] == 2834) catch @panic("test failure");
	10613	expect(v[25] == 2835) catch @panic("test failure");
	10614	expect(v[26] == 2836) catch @panic("test failure");
	10615	expect(v[27] == 2837) catch @panic("test failure");
	10616	expect(v[28] == 2838) catch @panic("test failure");
	10617	expect(v[29] == 2839) catch @panic("test failure");
	10618	expect(v[30] == 2840) catch @panic("test failure");
	10619	expect(v[31] == 2841) catch @panic("test failure");
	10620	expect(v[32] == 2842) catch @panic("test failure");
	10621	expect(v[33] == 2843) catch @panic("test failure");
	10622	expect(v[34] == 2844) catch @panic("test failure");
	10623	expect(v[35] == 2845) catch @panic("test failure");
	10624	expect(v[36] == 2846) catch @panic("test failure");
	10625	expect(v[37] == 2847) catch @panic("test failure");
	10626	expect(v[38] == 2848) catch @panic("test failure");
	10627	expect(v[39] == 2849) catch @panic("test failure");
	10628	expect(v[40] == 2850) catch @panic("test failure");
	10629	expect(v[41] == 2851) catch @panic("test failure");
	10630	expect(v[42] == 2852) catch @panic("test failure");
	10631	expect(v[43] == 2853) catch @panic("test failure");
	10632	expect(v[44] == 2854) catch @panic("test failure");
	10633	expect(v[45] == 2855) catch @panic("test failure");
	10634	expect(v[46] == 2856) catch @panic("test failure");
	10635	expect(v[47] == 2857) catch @panic("test failure");
	10636	expect(v[48] == 2858) catch @panic("test failure");
	10637	expect(v[49] == 2859) catch @panic("test failure");
	10638	expect(v[50] == 2860) catch @panic("test failure");
	10639	expect(v[51] == 2861) catch @panic("test failure");
	10640	expect(v[52] == 2862) catch @panic("test failure");
	10641	expect(v[53] == 2863) catch @panic("test failure");
	10642	expect(v[54] == 2864) catch @panic("test failure");
	10643	expect(v[55] == 2865) catch @panic("test failure");
	10644	expect(v[56] == 2866) catch @panic("test failure");
	10645	expect(v[57] == 2867) catch @panic("test failure");
	10646	expect(v[58] == 2868) catch @panic("test failure");
	10647	expect(v[59] == 2869) catch @panic("test failure");
	10648	expect(v[60] == 2870) catch @panic("test failure");
	10649	expect(v[61] == 2871) catch @panic("test failure");
	10650	expect(v[62] == 2872) catch @panic("test failure");
	10651	expect(v[63] == 2873) catch @panic("test failure");
	10652	expect(v[64] == 2874) catch @panic("test failure");
	10653	expect(v[65] == 2875) catch @panic("test failure");
	10654	expect(v[66] == 2876) catch @panic("test failure");
	10655	expect(v[67] == 2877) catch @panic("test failure");
	10656	expect(v[68] == 2878) catch @panic("test failure");
	10657	expect(v[69] == 2879) catch @panic("test failure");
	10658	expect(v[70] == 2880) catch @panic("test failure");
	10659	expect(v[71] == 2881) catch @panic("test failure");
	10660	expect(v[72] == 2882) catch @panic("test failure");
	10661	expect(v[73] == 2883) catch @panic("test failure");
	10662	expect(v[74] == 2884) catch @panic("test failure");
	10663	expect(v[75] == 2885) catch @panic("test failure");
	10664	expect(v[76] == 2886) catch @panic("test failure");
	10665	expect(v[77] == 2887) catch @panic("test failure");
	10666	expect(v[78] == 2888) catch @panic("test failure");
	10667	expect(v[79] == 2889) catch @panic("test failure");
	10668	expect(v[80] == 2890) catch @panic("test failure");
	10669	expect(v[81] == 2891) catch @panic("test failure");
	10670	expect(v[82] == 2892) catch @panic("test failure");
	10671	expect(v[83] == 2893) catch @panic("test failure");
	10672	expect(v[84] == 2894) catch @panic("test failure");
	10673	expect(v[85] == 2895) catch @panic("test failure");
	10674	expect(v[86] == 2896) catch @panic("test failure");
	10675	expect(v[87] == 2897) catch @panic("test failure");
	10676	expect(v[88] == 2898) catch @panic("test failure");
	10677	expect(v[89] == 2899) catch @panic("test failure");
	10678	expect(v[90] == 2900) catch @panic("test failure");
	10679	expect(v[91] == 2901) catch @panic("test failure");
	10680	expect(v[92] == 2902) catch @panic("test failure");
	10681	expect(v[93] == 2903) catch @panic("test failure");
	10682	expect(v[94] == 2904) catch @panic("test failure");
	10683	expect(v[95] == 2905) catch @panic("test failure");
	10684	expect(v[96] == 2906) catch @panic("test failure");
	10685	expect(v[97] == 2907) catch @panic("test failure");
	10686	expect(v[98] == 2908) catch @panic("test failure");
	10687	expect(v[99] == 2909) catch @panic("test failure");
	10688	expect(v[100] == 2910) catch @panic("test failure");
	10689	expect(v[101] == 2911) catch @panic("test failure");
	10690	expect(v[102] == 2912) catch @panic("test failure");
	10691	expect(v[103] == 2913) catch @panic("test failure");
	10692	expect(v[104] == 2914) catch @panic("test failure");
	10693	expect(v[105] == 2915) catch @panic("test failure");
	10694	expect(v[106] == 2916) catch @panic("test failure");
	10695	expect(v[107] == 2917) catch @panic("test failure");
	10696	expect(v[108] == 2918) catch @panic("test failure");
	10697	expect(v[109] == 2919) catch @panic("test failure");
	10698	expect(v[110] == 2920) catch @panic("test failure");
	10699	expect(v[111] == 2921) catch @panic("test failure");
	10700	expect(v[112] == 2922) catch @panic("test failure");
	10701	expect(v[113] == 2923) catch @panic("test failure");
	10702	expect(v[114] == 2924) catch @panic("test failure");
	10703	expect(v[115] == 2925) catch @panic("test failure");
	10704	expect(v[116] == 2926) catch @panic("test failure");
	10705	expect(v[117] == 2927) catch @panic("test failure");
	10706	expect(v[118] == 2928) catch @panic("test failure");
	10707	expect(v[119] == 2929) catch @panic("test failure");
	10708	expect(v[120] == 2930) catch @panic("test failure");
	10709	expect(v[121] == 2931) catch @panic("test failure");
	10710	expect(v[122] == 2932) catch @panic("test failure");
	10711	expect(v[123] == 2933) catch @panic("test failure");
	10712	expect(v[124] == 2934) catch @panic("test failure");
	10713	expect(v[125] == 2935) catch @panic("test failure");
	10714	expect(v[126] == 2936) catch @panic("test failure");
	10715	expect(v[127] == 2937) catch @panic("test failure");
	10716	expect(v[128] == 2938) catch @panic("test failure");
	10717	expect(v[129] == 2939) catch @panic("test failure");
	10718	expect(v[130] == 2940) catch @panic("test failure");
	10719	expect(v[131] == 2941) catch @panic("test failure");
	10720	expect(v[132] == 2942) catch @panic("test failure");
	10721	expect(v[133] == 2943) catch @panic("test failure");
	10722	expect(v[134] == 2944) catch @panic("test failure");
	10723	expect(v[135] == 2945) catch @panic("test failure");
	10724	expect(v[136] == 2946) catch @panic("test failure");
	10725	expect(v[137] == 2947) catch @panic("test failure");
	10726	expect(v[138] == 2948) catch @panic("test failure");
	10727	expect(v[139] == 2949) catch @panic("test failure");
	10728	expect(v[140] == 2950) catch @panic("test failure");
	10729	expect(v[141] == 2951) catch @panic("test failure");
	10730	expect(v[142] == 2952) catch @panic("test failure");
	10731	expect(v[143] == 2953) catch @panic("test failure");
	10732	expect(v[144] == 2954) catch @panic("test failure");
	10733	expect(v[145] == 2955) catch @panic("test failure");
	10734	expect(v[146] == 2956) catch @panic("test failure");
	10735	expect(v[147] == 2957) catch @panic("test failure");
	10736	expect(v[148] == 2958) catch @panic("test failure");
	10737	expect(v[149] == 2959) catch @panic("test failure");
	10738	expect(v[150] == 2960) catch @panic("test failure");
	10739	expect(v[151] == 2961) catch @panic("test failure");
	10740	expect(v[152] == 2962) catch @panic("test failure");
	10741	expect(v[153] == 2963) catch @panic("test failure");
	10742	expect(v[154] == 2964) catch @panic("test failure");
	10743	expect(v[155] == 2965) catch @panic("test failure");
	10744	expect(v[156] == 2966) catch @panic("test failure");
	10745	expect(v[157] == 2967) catch @panic("test failure");
	10746	expect(v[158] == 2968) catch @panic("test failure");
	10747	expect(v[159] == 2969) catch @panic("test failure");
	10748	expect(v[160] == 2970) catch @panic("test failure");
	10749	expect(v[161] == 2971) catch @panic("test failure");
	10750	expect(v[162] == 2972) catch @panic("test failure");
	10751	expect(v[163] == 2973) catch @panic("test failure");
	10752	expect(v[164] == 2974) catch @panic("test failure");
	10753	expect(v[165] == 2975) catch @panic("test failure");
	10754	expect(v[166] == 2976) catch @panic("test failure");
	10755	expect(v[167] == 2977) catch @panic("test failure");
	10756	expect(v[168] == 2978) catch @panic("test failure");
	10757	expect(v[169] == 2979) catch @panic("test failure");
	10758	expect(v[170] == 2980) catch @panic("test failure");
	10759	expect(v[171] == 2981) catch @panic("test failure");
	10760	expect(v[172] == 2982) catch @panic("test failure");
	10761	expect(v[173] == 2983) catch @panic("test failure");
	10762	expect(v[174] == 2984) catch @panic("test failure");
	10763	expect(v[175] == 2985) catch @panic("test failure");
	10764	expect(v[176] == 2986) catch @panic("test failure");
	10765	expect(v[177] == 2987) catch @panic("test failure");
	10766	expect(v[178] == 2988) catch @panic("test failure");
	10767	expect(v[179] == 2989) catch @panic("test failure");
	10768	expect(v[180] == 2990) catch @panic("test failure");
	10769	expect(v[181] == 2991) catch @panic("test failure");
	10770	expect(v[182] == 2992) catch @panic("test failure");
	10771	expect(v[183] == 2993) catch @panic("test failure");
	10772	expect(v[184] == 2994) catch @panic("test failure");
	10773	expect(v[185] == 2995) catch @panic("test failure");
	10774	expect(v[186] == 2996) catch @panic("test failure");
	10775	expect(v[187] == 2997) catch @panic("test failure");
	10776	expect(v[188] == 2998) catch @panic("test failure");
	10777	expect(v[189] == 2999) catch @panic("test failure");
	10778	expect(v[190] == 3000) catch @panic("test failure");
	10779	expect(v[191] == 3001) catch @panic("test failure");
	10780	expect(v[192] == 3002) catch @panic("test failure");
	10781	expect(v[193] == 3003) catch @panic("test failure");
	10782	expect(v[194] == 3004) catch @panic("test failure");
	10783	expect(v[195] == 3005) catch @panic("test failure");
	10784	expect(v[196] == 3006) catch @panic("test failure");
	10785	expect(v[197] == 3007) catch @panic("test failure");
	10786	expect(v[198] == 3008) catch @panic("test failure");
	10787	expect(v[199] == 3009) catch @panic("test failure");
	10788	expect(v[200] == 3010) catch @panic("test failure");
	10789	expect(v[201] == 3011) catch @panic("test failure");
	10790	expect(v[202] == 3012) catch @panic("test failure");
	10791	expect(v[203] == 3013) catch @panic("test failure");
	10792	expect(v[204] == 3014) catch @panic("test failure");
	10793	expect(v[205] == 3015) catch @panic("test failure");
	10794	expect(v[206] == 3016) catch @panic("test failure");
	10795	expect(v[207] == 3017) catch @panic("test failure");
	10796	expect(v[208] == 3018) catch @panic("test failure");
	10797	expect(v[209] == 3019) catch @panic("test failure");
	10798	expect(v[210] == 3020) catch @panic("test failure");
	10799	expect(v[211] == 3021) catch @panic("test failure");
	10800	expect(v[212] == 3022) catch @panic("test failure");
	10801	expect(v[213] == 3023) catch @panic("test failure");
	10802	expect(v[214] == 3024) catch @panic("test failure");
	10803	expect(v[215] == 3025) catch @panic("test failure");
	10804	expect(v[216] == 3026) catch @panic("test failure");
	10805	expect(v[217] == 3027) catch @panic("test failure");
	10806	expect(v[218] == 3028) catch @panic("test failure");
	10807	expect(v[219] == 3029) catch @panic("test failure");
	10808	expect(v[220] == 3030) catch @panic("test failure");
	10809	expect(v[221] == 3031) catch @panic("test failure");
	10810	expect(v[222] == 3032) catch @panic("test failure");
	10811	expect(v[223] == 3033) catch @panic("test failure");
	10812	expect(v[224] == 3034) catch @panic("test failure");
	10813	expect(v[225] == 3035) catch @panic("test failure");
	10814	expect(v[226] == 3036) catch @panic("test failure");
	10815	expect(v[227] == 3037) catch @panic("test failure");
	10816	expect(v[228] == 3038) catch @panic("test failure");
	10817	expect(v[229] == 3039) catch @panic("test failure");
	10818	expect(v[230] == 3040) catch @panic("test failure");
	10819	expect(v[231] == 3041) catch @panic("test failure");
	10820	expect(v[232] == 3042) catch @panic("test failure");
	10821	expect(v[233] == 3043) catch @panic("test failure");
	10822	expect(v[234] == 3044) catch @panic("test failure");
	10823	expect(v[235] == 3045) catch @panic("test failure");
	10824	expect(v[236] == 3046) catch @panic("test failure");
	10825	expect(v[237] == 3047) catch @panic("test failure");
	10826	expect(v[238] == 3048) catch @panic("test failure");
	10827	expect(v[239] == 3049) catch @panic("test failure");
	10828	expect(v[240] == 3050) catch @panic("test failure");
	10829	expect(v[241] == 3051) catch @panic("test failure");
	10830	expect(v[242] == 3052) catch @panic("test failure");
	10831	expect(v[243] == 3053) catch @panic("test failure");
	10832	expect(v[244] == 3054) catch @panic("test failure");
	10833	expect(v[245] == 3055) catch @panic("test failure");
	10834	expect(v[246] == 3056) catch @panic("test failure");
	10835	expect(v[247] == 3057) catch @panic("test failure");
	10836	expect(v[248] == 3058) catch @panic("test failure");
	10837	expect(v[249] == 3059) catch @panic("test failure");
	10838	expect(v[250] == 3060) catch @panic("test failure");
	10839	expect(v[251] == 3061) catch @panic("test failure");
	10840	expect(v[252] == 3062) catch @panic("test failure");
	10841	expect(v[253] == 3063) catch @panic("test failure");
	10842	expect(v[254] == 3064) catch @panic("test failure");
	10843	expect(v[255] == 3065) catch @panic("test failure");
	10844	expect(i == 256) catch @panic("test failure");
	10845	}
	10846
	10847	extern fn c_ret_vector_256_u16() @Vector(256, u16);
	10848	extern fn c_vector_256_u16(@Vector(256, u16), usize) void;
	10849	extern fn c_test_vector_256_u16() void;
	10850
	10851	test "@Vector(256, u16)" {
	10852	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	10853	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	10854	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	10855	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	10856	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	10857
	10858	const v = c_ret_vector_256_u16();
	10859	try expect(v[0] == 3066);
	10860	try expect(v[1] == 3067);
	10861	try expect(v[2] == 3068);
	10862	try expect(v[3] == 3069);
	10863	try expect(v[4] == 3070);
	10864	try expect(v[5] == 3071);
	10865	try expect(v[6] == 3072);
	10866	try expect(v[7] == 3073);
	10867	try expect(v[8] == 3074);
	10868	try expect(v[9] == 3075);
	10869	try expect(v[10] == 3076);
	10870	try expect(v[11] == 3077);
	10871	try expect(v[12] == 3078);
	10872	try expect(v[13] == 3079);
	10873	try expect(v[14] == 3080);
	10874	try expect(v[15] == 3081);
	10875	try expect(v[16] == 3082);
	10876	try expect(v[17] == 3083);
	10877	try expect(v[18] == 3084);
	10878	try expect(v[19] == 3085);
	10879	try expect(v[20] == 3086);
	10880	try expect(v[21] == 3087);
	10881	try expect(v[22] == 3088);
	10882	try expect(v[23] == 3089);
	10883	try expect(v[24] == 3090);
	10884	try expect(v[25] == 3091);
	10885	try expect(v[26] == 3092);
	10886	try expect(v[27] == 3093);
	10887	try expect(v[28] == 3094);
	10888	try expect(v[29] == 3095);
	10889	try expect(v[30] == 3096);
	10890	try expect(v[31] == 3097);
	10891	try expect(v[32] == 3098);
	10892	try expect(v[33] == 3099);
	10893	try expect(v[34] == 3100);
	10894	try expect(v[35] == 3101);
	10895	try expect(v[36] == 3102);
	10896	try expect(v[37] == 3103);
	10897	try expect(v[38] == 3104);
	10898	try expect(v[39] == 3105);
	10899	try expect(v[40] == 3106);
	10900	try expect(v[41] == 3107);
	10901	try expect(v[42] == 3108);
	10902	try expect(v[43] == 3109);
	10903	try expect(v[44] == 3110);
	10904	try expect(v[45] == 3111);
	10905	try expect(v[46] == 3112);
	10906	try expect(v[47] == 3113);
	10907	try expect(v[48] == 3114);
	10908	try expect(v[49] == 3115);
	10909	try expect(v[50] == 3116);
	10910	try expect(v[51] == 3117);
	10911	try expect(v[52] == 3118);
	10912	try expect(v[53] == 3119);
	10913	try expect(v[54] == 3120);
	10914	try expect(v[55] == 3121);
	10915	try expect(v[56] == 3122);
	10916	try expect(v[57] == 3123);
	10917	try expect(v[58] == 3124);
	10918	try expect(v[59] == 3125);
	10919	try expect(v[60] == 3126);
	10920	try expect(v[61] == 3127);
	10921	try expect(v[62] == 3128);
	10922	try expect(v[63] == 3129);
	10923	try expect(v[64] == 3130);
	10924	try expect(v[65] == 3131);
	10925	try expect(v[66] == 3132);
	10926	try expect(v[67] == 3133);
	10927	try expect(v[68] == 3134);
	10928	try expect(v[69] == 3135);
	10929	try expect(v[70] == 3136);
	10930	try expect(v[71] == 3137);
	10931	try expect(v[72] == 3138);
	10932	try expect(v[73] == 3139);
	10933	try expect(v[74] == 3140);
	10934	try expect(v[75] == 3141);
	10935	try expect(v[76] == 3142);
	10936	try expect(v[77] == 3143);
	10937	try expect(v[78] == 3144);
	10938	try expect(v[79] == 3145);
	10939	try expect(v[80] == 3146);
	10940	try expect(v[81] == 3147);
	10941	try expect(v[82] == 3148);
	10942	try expect(v[83] == 3149);
	10943	try expect(v[84] == 3150);
	10944	try expect(v[85] == 3151);
	10945	try expect(v[86] == 3152);
	10946	try expect(v[87] == 3153);
	10947	try expect(v[88] == 3154);
	10948	try expect(v[89] == 3155);
	10949	try expect(v[90] == 3156);
	10950	try expect(v[91] == 3157);
	10951	try expect(v[92] == 3158);
	10952	try expect(v[93] == 3159);
	10953	try expect(v[94] == 3160);
	10954	try expect(v[95] == 3161);
	10955	try expect(v[96] == 3162);
	10956	try expect(v[97] == 3163);
	10957	try expect(v[98] == 3164);
	10958	try expect(v[99] == 3165);
	10959	try expect(v[100] == 3166);
	10960	try expect(v[101] == 3167);
	10961	try expect(v[102] == 3168);
	10962	try expect(v[103] == 3169);
	10963	try expect(v[104] == 3170);
	10964	try expect(v[105] == 3171);
	10965	try expect(v[106] == 3172);
	10966	try expect(v[107] == 3173);
	10967	try expect(v[108] == 3174);
	10968	try expect(v[109] == 3175);
	10969	try expect(v[110] == 3176);
	10970	try expect(v[111] == 3177);
	10971	try expect(v[112] == 3178);
	10972	try expect(v[113] == 3179);
	10973	try expect(v[114] == 3180);
	10974	try expect(v[115] == 3181);
	10975	try expect(v[116] == 3182);
	10976	try expect(v[117] == 3183);
	10977	try expect(v[118] == 3184);
	10978	try expect(v[119] == 3185);
	10979	try expect(v[120] == 3186);
	10980	try expect(v[121] == 3187);
	10981	try expect(v[122] == 3188);
	10982	try expect(v[123] == 3189);
	10983	try expect(v[124] == 3190);
	10984	try expect(v[125] == 3191);
	10985	try expect(v[126] == 3192);
	10986	try expect(v[127] == 3193);
	10987	try expect(v[128] == 3194);
	10988	try expect(v[129] == 3195);
	10989	try expect(v[130] == 3196);
	10990	try expect(v[131] == 3197);
	10991	try expect(v[132] == 3198);
	10992	try expect(v[133] == 3199);
	10993	try expect(v[134] == 3200);
	10994	try expect(v[135] == 3201);
	10995	try expect(v[136] == 3202);
	10996	try expect(v[137] == 3203);
	10997	try expect(v[138] == 3204);
	10998	try expect(v[139] == 3205);
	10999	try expect(v[140] == 3206);
	11000	try expect(v[141] == 3207);
	11001	try expect(v[142] == 3208);
	11002	try expect(v[143] == 3209);
	11003	try expect(v[144] == 3210);
	11004	try expect(v[145] == 3211);
	11005	try expect(v[146] == 3212);
	11006	try expect(v[147] == 3213);
	11007	try expect(v[148] == 3214);
	11008	try expect(v[149] == 3215);
	11009	try expect(v[150] == 3216);
	11010	try expect(v[151] == 3217);
	11011	try expect(v[152] == 3218);
	11012	try expect(v[153] == 3219);
	11013	try expect(v[154] == 3220);
	11014	try expect(v[155] == 3221);
	11015	try expect(v[156] == 3222);
	11016	try expect(v[157] == 3223);
	11017	try expect(v[158] == 3224);
	11018	try expect(v[159] == 3225);
	11019	try expect(v[160] == 3226);
	11020	try expect(v[161] == 3227);
	11021	try expect(v[162] == 3228);
	11022	try expect(v[163] == 3229);
	11023	try expect(v[164] == 3230);
	11024	try expect(v[165] == 3231);
	11025	try expect(v[166] == 3232);
	11026	try expect(v[167] == 3233);
	11027	try expect(v[168] == 3234);
	11028	try expect(v[169] == 3235);
	11029	try expect(v[170] == 3236);
	11030	try expect(v[171] == 3237);
	11031	try expect(v[172] == 3238);
	11032	try expect(v[173] == 3239);
	11033	try expect(v[174] == 3240);
	11034	try expect(v[175] == 3241);
	11035	try expect(v[176] == 3242);
	11036	try expect(v[177] == 3243);
	11037	try expect(v[178] == 3244);
	11038	try expect(v[179] == 3245);
	11039	try expect(v[180] == 3246);
	11040	try expect(v[181] == 3247);
	11041	try expect(v[182] == 3248);
	11042	try expect(v[183] == 3249);
	11043	try expect(v[184] == 3250);
	11044	try expect(v[185] == 3251);
	11045	try expect(v[186] == 3252);
	11046	try expect(v[187] == 3253);
	11047	try expect(v[188] == 3254);
	11048	try expect(v[189] == 3255);
	11049	try expect(v[190] == 3256);
	11050	try expect(v[191] == 3257);
	11051	try expect(v[192] == 3258);
	11052	try expect(v[193] == 3259);
	11053	try expect(v[194] == 3260);
	11054	try expect(v[195] == 3261);
	11055	try expect(v[196] == 3262);
	11056	try expect(v[197] == 3263);
	11057	try expect(v[198] == 3264);
	11058	try expect(v[199] == 3265);
	11059	try expect(v[200] == 3266);
	11060	try expect(v[201] == 3267);
	11061	try expect(v[202] == 3268);
	11062	try expect(v[203] == 3269);
	11063	try expect(v[204] == 3270);
	11064	try expect(v[205] == 3271);
	11065	try expect(v[206] == 3272);
	11066	try expect(v[207] == 3273);
	11067	try expect(v[208] == 3274);
	11068	try expect(v[209] == 3275);
	11069	try expect(v[210] == 3276);
	11070	try expect(v[211] == 3277);
	11071	try expect(v[212] == 3278);
	11072	try expect(v[213] == 3279);
	11073	try expect(v[214] == 3280);
	11074	try expect(v[215] == 3281);
	11075	try expect(v[216] == 3282);
	11076	try expect(v[217] == 3283);
	11077	try expect(v[218] == 3284);
	11078	try expect(v[219] == 3285);
	11079	try expect(v[220] == 3286);
	11080	try expect(v[221] == 3287);
	11081	try expect(v[222] == 3288);
	11082	try expect(v[223] == 3289);
	11083	try expect(v[224] == 3290);
	11084	try expect(v[225] == 3291);
	11085	try expect(v[226] == 3292);
	11086	try expect(v[227] == 3293);
	11087	try expect(v[228] == 3294);
	11088	try expect(v[229] == 3295);
	11089	try expect(v[230] == 3296);
	11090	try expect(v[231] == 3297);
	11091	try expect(v[232] == 3298);
	11092	try expect(v[233] == 3299);
	11093	try expect(v[234] == 3300);
	11094	try expect(v[235] == 3301);
	11095	try expect(v[236] == 3302);
	11096	try expect(v[237] == 3303);
	11097	try expect(v[238] == 3304);
	11098	try expect(v[239] == 3305);
	11099	try expect(v[240] == 3306);
	11100	try expect(v[241] == 3307);
	11101	try expect(v[242] == 3308);
	11102	try expect(v[243] == 3309);
	11103	try expect(v[244] == 3310);
	11104	try expect(v[245] == 3311);
	11105	try expect(v[246] == 3312);
	11106	try expect(v[247] == 3313);
	11107	try expect(v[248] == 3314);
	11108	try expect(v[249] == 3315);
	11109	try expect(v[250] == 3316);
	11110	try expect(v[251] == 3317);
	11111	try expect(v[252] == 3318);
	11112	try expect(v[253] == 3319);
	11113	try expect(v[254] == 3320);
	11114	try expect(v[255] == 3321);
	11115	c_vector_256_u16(.{
	11116	3322, 3323, 3324, 3325, 3326, 3327, 3328, 3329, 3330, 3331, 3332, 3333, 3334, 3335, 3336, 3337,
	11117	3338, 3339, 3340, 3341, 3342, 3343, 3344, 3345, 3346, 3347, 3348, 3349, 3350, 3351, 3352, 3353,
	11118	3354, 3355, 3356, 3357, 3358, 3359, 3360, 3361, 3362, 3363, 3364, 3365, 3366, 3367, 3368, 3369,
	11119	3370, 3371, 3372, 3373, 3374, 3375, 3376, 3377, 3378, 3379, 3380, 3381, 3382, 3383, 3384, 3385,
	11120	3386, 3387, 3388, 3389, 3390, 3391, 3392, 3393, 3394, 3395, 3396, 3397, 3398, 3399, 3400, 3401,
	11121	3402, 3403, 3404, 3405, 3406, 3407, 3408, 3409, 3410, 3411, 3412, 3413, 3414, 3415, 3416, 3417,
	11122	3418, 3419, 3420, 3421, 3422, 3423, 3424, 3425, 3426, 3427, 3428, 3429, 3430, 3431, 3432, 3433,
	11123	3434, 3435, 3436, 3437, 3438, 3439, 3440, 3441, 3442, 3443, 3444, 3445, 3446, 3447, 3448, 3449,
	11124	3450, 3451, 3452, 3453, 3454, 3455, 3456, 3457, 3458, 3459, 3460, 3461, 3462, 3463, 3464, 3465,
	11125	3466, 3467, 3468, 3469, 3470, 3471, 3472, 3473, 3474, 3475, 3476, 3477, 3478, 3479, 3480, 3481,
	11126	3482, 3483, 3484, 3485, 3486, 3487, 3488, 3489, 3490, 3491, 3492, 3493, 3494, 3495, 3496, 3497,
	11127	3498, 3499, 3500, 3501, 3502, 3503, 3504, 3505, 3506, 3507, 3508, 3509, 3510, 3511, 3512, 3513,
	11128	3514, 3515, 3516, 3517, 3518, 3519, 3520, 3521, 3522, 3523, 3524, 3525, 3526, 3527, 3528, 3529,
	11129	3530, 3531, 3532, 3533, 3534, 3535, 3536, 3537, 3538, 3539, 3540, 3541, 3542, 3543, 3544, 3545,
	11130	3546, 3547, 3548, 3549, 3550, 3551, 3552, 3553, 3554, 3555, 3556, 3557, 3558, 3559, 3560, 3561,
	11131	3562, 3563, 3564, 3565, 3566, 3567, 3568, 3569, 3570, 3571, 3572, 3573, 3574, 3575, 3576, 3577,
	11132	}, 256);
	11133	c_test_vector_256_u16();
	11134	}
	11135
	11136	export fn zig_ret_vector_1_u32() @Vector(1, u32) {
	11137	return .{1};
	11138	}
	11139	export fn zig_vector_1_u32(v: @Vector(1, u32), i: usize) void {
	11140	expect(v[0] == 2) catch @panic("test failure");
	11141	expect(i == 1) catch @panic("test failure");
	11142	}
	11143
	11144	extern fn c_ret_vector_1_u32() @Vector(1, u32);
	11145	extern fn c_vector_1_u32(@Vector(1, u32), usize) void;
	11146	extern fn c_test_vector_1_u32() void;
	11147
	11148	test "@Vector(1, u32)" {
	11149	if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
	11150	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	11151
	11152	const v = c_ret_vector_1_u32();
	11153	try expect(v[0] == 3);
	11154	c_vector_1_u32(.{4}, 1);
	11155	c_test_vector_1_u32();
	11156	}
	11157
	11158	export fn zig_ret_vector_2_u32() @Vector(2, u32) {
	11159	return .{ 5, 6 };
	11160	}
	11161	export fn zig_vector_2_u32(v: @Vector(2, u32), i: usize) void {
	11162	expect(v[0] == 7) catch @panic("test failure");
	11163	expect(v[1] == 8) catch @panic("test failure");
	11164	expect(i == 2) catch @panic("test failure");
	11165	}
	11166
	11167	extern fn c_ret_vector_2_u32() @Vector(2, u32);
	11168	extern fn c_vector_2_u32(@Vector(2, u32), usize) void;
	11169	extern fn c_test_vector_2_u32() void;
	11170
	11171	test "@Vector(2, u32)" {
	11172	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	11173	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	11174	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	11175	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
	11176
	11177	const v = c_ret_vector_2_u32();
	11178	try expect(v[0] == 9);
	11179	try expect(v[1] == 10);
	11180	c_vector_2_u32(.{ 11, 12 }, 2);
	11181	c_test_vector_2_u32();
	11182	}
	11183
	11184	export fn zig_ret_vector_3_u32() @Vector(3, u32) {
	11185	return .{ 13, 14, 15 };
	11186	}
	11187	export fn zig_vector_3_u32(v: @Vector(3, u32), i: usize) void {
	11188	expect(v[0] == 16) catch @panic("test failure");
	11189	expect(v[1] == 17) catch @panic("test failure");
	11190	expect(v[2] == 18) catch @panic("test failure");
	11191	expect(i == 3) catch @panic("test failure");
	11192	}
	11193
	11194	extern fn c_ret_vector_3_u32() @Vector(3, u32);
	11195	extern fn c_vector_3_u32(@Vector(3, u32), usize) void;
	11196	extern fn c_test_vector_3_u32() void;
	11197
	11198	test "@Vector(3, u32)" {
	11199	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	11200	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	11201	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	11202
	11203	const v = c_ret_vector_3_u32();
	11204	try expect(v[0] == 19);
	11205	try expect(v[1] == 20);
	11206	try expect(v[2] == 21);
	11207	c_vector_3_u32(.{ 22, 23, 24 }, 3);
	11208	c_test_vector_3_u32();
	11209	}
	11210
	11211	export fn zig_ret_vector_4_u32() @Vector(4, u32) {
	11212	return .{ 25, 26, 27, 28 };
	11213	}
	11214	export fn zig_vector_4_u32(v: @Vector(4, u32), i: usize) void {
	11215	expect(v[0] == 29) catch @panic("test failure");
	11216	expect(v[1] == 30) catch @panic("test failure");
	11217	expect(v[2] == 31) catch @panic("test failure");
	11218	expect(v[3] == 32) catch @panic("test failure");
	11219	expect(i == 4) catch @panic("test failure");
	11220	}
	11221	export fn zig_vector_4_u32_vector_4_u32(v0: @Vector(4, u32), v1: @Vector(4, u32), i: usize) void {
	11222	expect(v0[0] == 33) catch @panic("test failure");
	11223	expect(v0[1] == 34) catch @panic("test failure");
	11224	expect(v0[2] == 35) catch @panic("test failure");
	11225	expect(v0[3] == 36) catch @panic("test failure");
	11226	expect(v1[0] == 37) catch @panic("test failure");
	11227	expect(v1[1] == 38) catch @panic("test failure");
	11228	expect(v1[2] == 39) catch @panic("test failure");
	11229	expect(v1[3] == 40) catch @panic("test failure");
	11230	expect(i == 8) catch @panic("test failure");
	11231	}
	11232
	11233	extern fn c_ret_vector_4_u32() @Vector(4, u32);
	11234	extern fn c_vector_4_u32(@Vector(4, u32), usize) void;
	11235	extern fn c_vector_4_u32_vector_4_u32(@Vector(4, u32), @Vector(4, u32), usize) void;
	11236	extern fn c_test_vector_4_u32() void;
	11237
	11238	test "@Vector(4, u32)" {
	11239	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	11240
	11241	const v = c_ret_vector_4_u32();
	11242	try expect(v[0] == 41);
	11243	try expect(v[1] == 42);
	11244	try expect(v[2] == 43);
	11245	try expect(v[3] == 44);
	11246	c_vector_4_u32(.{ 45, 46, 47, 48 }, 4);
	11247	c_vector_4_u32_vector_4_u32(.{ 49, 50, 51, 52 }, .{ 53, 54, 55, 56 }, 8);
	11248	c_test_vector_4_u32();
	11249	}
	11250
	11251	export fn zig_ret_vector_6_u32() @Vector(6, u32) {
	11252	return .{ 41, 42, 43, 44, 45, 46 };
	11253	}
	11254	export fn zig_vector_6_u32(v: @Vector(6, u32), i: usize) void {
	11255	expect(v[0] == 47) catch @panic("test failure");
	11256	expect(v[1] == 48) catch @panic("test failure");
	11257	expect(v[2] == 49) catch @panic("test failure");
	11258	expect(v[3] == 50) catch @panic("test failure");
	11259	expect(v[4] == 51) catch @panic("test failure");
	11260	expect(v[5] == 52) catch @panic("test failure");
	11261	expect(i == 6) catch @panic("test failure");
	11262	}
	11263
	11264	extern fn c_ret_vector_6_u32() @Vector(6, u32);
	11265	extern fn c_vector_6_u32(@Vector(6, u32), usize) void;
	11266	extern fn c_test_vector_6_u32() void;
	11267
	11268	test "@Vector(6, u32)" {
	11269	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	11270	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	11271	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	11272	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	11273	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	11274
	11275	const v = c_ret_vector_6_u32();
	11276	try expect(v[0] == 53);
	11277	try expect(v[1] == 54);
	11278	try expect(v[2] == 55);
	11279	try expect(v[3] == 56);
	11280	try expect(v[4] == 57);
	11281	try expect(v[5] == 58);
	11282	c_vector_6_u32(.{ 59, 60, 61, 62, 63, 64 }, 6);
	11283	c_test_vector_6_u32();
	11284	}
	11285
	11286	export fn zig_ret_vector_8_u32() @Vector(8, u32) {
	11287	return .{ 65, 66, 67, 68, 69, 70, 71, 72 };
	11288	}
	11289	export fn zig_vector_8_u32(v: @Vector(8, u32), i: usize) void {
	11290	expect(v[0] == 73) catch @panic("test failure");
	11291	expect(v[1] == 74) catch @panic("test failure");
	11292	expect(v[2] == 75) catch @panic("test failure");
	11293	expect(v[3] == 76) catch @panic("test failure");
	11294	expect(v[4] == 77) catch @panic("test failure");
	11295	expect(v[5] == 78) catch @panic("test failure");
	11296	expect(v[6] == 79) catch @panic("test failure");
	11297	expect(v[7] == 80) catch @panic("test failure");
	11298	expect(i == 8) catch @panic("test failure");
	11299	}
	11300
	11301	extern fn c_ret_vector_8_u32() @Vector(8, u32);
	11302	extern fn c_vector_8_u32(@Vector(8, u32), usize) void;
	11303	extern fn c_test_vector_8_u32() void;
	11304
	11305	test "@Vector(8, u32)" {
	11306	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	11307	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	11308	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	11309	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	11310
	11311	const v = c_ret_vector_8_u32();
	11312	try expect(v[0] == 81);
	11313	try expect(v[1] == 82);
	11314	try expect(v[2] == 83);
	11315	try expect(v[3] == 84);
	11316	try expect(v[4] == 85);
	11317	try expect(v[5] == 86);
	11318	try expect(v[6] == 87);
	11319	try expect(v[7] == 88);
	11320	c_vector_8_u32(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8);
	11321	c_test_vector_8_u32();
	11322	}
	11323
	11324	export fn zig_ret_vector_12_u32() @Vector(12, u32) {
	11325	return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 };
	11326	}
	11327	export fn zig_vector_12_u32(v: @Vector(12, u32), i: usize) void {
	11328	expect(v[0] == 109) catch @panic("test failure");
	11329	expect(v[1] == 110) catch @panic("test failure");
	11330	expect(v[2] == 111) catch @panic("test failure");
	11331	expect(v[3] == 112) catch @panic("test failure");
	11332	expect(v[4] == 113) catch @panic("test failure");
	11333	expect(v[5] == 114) catch @panic("test failure");
	11334	expect(v[6] == 115) catch @panic("test failure");
	11335	expect(v[7] == 116) catch @panic("test failure");
	11336	expect(v[8] == 117) catch @panic("test failure");
	11337	expect(v[9] == 118) catch @panic("test failure");
	11338	expect(v[10] == 119) catch @panic("test failure");
	11339	expect(v[11] == 120) catch @panic("test failure");
	11340	expect(i == 12) catch @panic("test failure");
	11341	}
	11342
	11343	extern fn c_ret_vector_12_u32() @Vector(12, u32);
	11344	extern fn c_vector_12_u32(@Vector(12, u32), usize) void;
	11345	extern fn c_test_vector_12_u32() void;
	11346
	11347	test "@Vector(12, u32)" {
	11348	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	11349	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	11350	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	11351	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	11352	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	11353
	11354	const v = c_ret_vector_12_u32();
	11355	try expect(v[0] == 121);
	11356	try expect(v[1] == 122);
	11357	try expect(v[2] == 123);
	11358	try expect(v[3] == 124);
	11359	try expect(v[4] == 125);
	11360	try expect(v[5] == 126);
	11361	try expect(v[6] == 127);
	11362	try expect(v[7] == 128);
	11363	try expect(v[8] == 129);
	11364	try expect(v[9] == 130);
	11365	try expect(v[10] == 131);
	11366	try expect(v[11] == 132);
	11367	c_vector_12_u32(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12);
	11368	c_test_vector_12_u32();
	11369	}
	11370
	11371	export fn zig_ret_vector_16_u32() @Vector(16, u32) {
	11372	return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 };
	11373	}
	11374	export fn zig_vector_16_u32(v: @Vector(16, u32), i: usize) void {
	11375	expect(v[0] == 161) catch @panic("test failure");
	11376	expect(v[1] == 162) catch @panic("test failure");
	11377	expect(v[2] == 163) catch @panic("test failure");
	11378	expect(v[3] == 164) catch @panic("test failure");
	11379	expect(v[4] == 165) catch @panic("test failure");
	11380	expect(v[5] == 166) catch @panic("test failure");
	11381	expect(v[6] == 167) catch @panic("test failure");
	11382	expect(v[7] == 168) catch @panic("test failure");
	11383	expect(v[8] == 169) catch @panic("test failure");
	11384	expect(v[9] == 170) catch @panic("test failure");
	11385	expect(v[10] == 171) catch @panic("test failure");
	11386	expect(v[11] == 172) catch @panic("test failure");
	11387	expect(v[12] == 173) catch @panic("test failure");
	11388	expect(v[13] == 174) catch @panic("test failure");
	11389	expect(v[14] == 175) catch @panic("test failure");
	11390	expect(v[15] == 176) catch @panic("test failure");
	11391	expect(i == 16) catch @panic("test failure");
	11392	}
	11393
	11394	extern fn c_ret_vector_16_u32() @Vector(16, u32);
	11395	extern fn c_vector_16_u32(@Vector(16, u32), usize) void;
	11396	extern fn c_test_vector_16_u32() void;
	11397
	11398	test "@Vector(16, u32)" {
	11399	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	11400	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	11401	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	11402	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	11403
	11404	const v = c_ret_vector_16_u32();
	11405	try expect(v[0] == 177);
	11406	try expect(v[1] == 178);
	11407	try expect(v[2] == 179);
	11408	try expect(v[3] == 180);
	11409	try expect(v[4] == 181);
	11410	try expect(v[5] == 182);
	11411	try expect(v[6] == 183);
	11412	try expect(v[7] == 184);
	11413	try expect(v[8] == 185);
	11414	try expect(v[9] == 186);
	11415	try expect(v[10] == 187);
	11416	try expect(v[11] == 188);
	11417	try expect(v[12] == 189);
	11418	try expect(v[13] == 190);
	11419	try expect(v[14] == 191);
	11420	try expect(v[15] == 192);
	11421	c_vector_16_u32(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16);
	11422	c_test_vector_16_u32();
	11423	}
	11424
	11425	export fn zig_ret_vector_24_u32() @Vector(24, u32) {
	11426	return .{
	11427	209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
	11428	225, 226, 227, 228, 229, 230, 231, 232,
	11429	};
	11430	}
	11431	export fn zig_vector_24_u32(v: @Vector(24, u32), i: usize) void {
	11432	expect(v[0] == 233) catch @panic("test failure");
	11433	expect(v[1] == 234) catch @panic("test failure");
	11434	expect(v[2] == 235) catch @panic("test failure");
	11435	expect(v[3] == 236) catch @panic("test failure");
	11436	expect(v[4] == 237) catch @panic("test failure");
	11437	expect(v[5] == 238) catch @panic("test failure");
	11438	expect(v[6] == 239) catch @panic("test failure");
	11439	expect(v[7] == 240) catch @panic("test failure");
	11440	expect(v[8] == 241) catch @panic("test failure");
	11441	expect(v[9] == 242) catch @panic("test failure");
	11442	expect(v[10] == 243) catch @panic("test failure");
	11443	expect(v[11] == 244) catch @panic("test failure");
	11444	expect(v[12] == 245) catch @panic("test failure");
	11445	expect(v[13] == 246) catch @panic("test failure");
	11446	expect(v[14] == 247) catch @panic("test failure");
	11447	expect(v[15] == 248) catch @panic("test failure");
	11448	expect(v[16] == 249) catch @panic("test failure");
	11449	expect(v[17] == 250) catch @panic("test failure");
	11450	expect(v[18] == 251) catch @panic("test failure");
	11451	expect(v[19] == 252) catch @panic("test failure");
	11452	expect(v[20] == 253) catch @panic("test failure");
	11453	expect(v[21] == 254) catch @panic("test failure");
	11454	expect(v[22] == 255) catch @panic("test failure");
	11455	expect(v[23] == 256) catch @panic("test failure");
	11456	expect(i == 24) catch @panic("test failure");
	11457	}
	11458
	11459	extern fn c_ret_vector_24_u32() @Vector(24, u32);
	11460	extern fn c_vector_24_u32(@Vector(24, u32), usize) void;
	11461	extern fn c_test_vector_24_u32() void;
	11462
	11463	test "@Vector(24, u32)" {
	11464	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	11465	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	11466	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	11467	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	11468	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	11469
	11470	const v = c_ret_vector_24_u32();
	11471	try expect(v[0] == 257);
	11472	try expect(v[1] == 258);
	11473	try expect(v[2] == 259);
	11474	try expect(v[3] == 260);
	11475	try expect(v[4] == 261);
	11476	try expect(v[5] == 262);
	11477	try expect(v[6] == 263);
	11478	try expect(v[7] == 264);
	11479	try expect(v[8] == 265);
	11480	try expect(v[9] == 266);
	11481	try expect(v[10] == 267);
	11482	try expect(v[11] == 268);
	11483	try expect(v[12] == 269);
	11484	try expect(v[13] == 270);
	11485	try expect(v[14] == 271);
	11486	try expect(v[15] == 272);
	11487	try expect(v[16] == 273);
	11488	try expect(v[17] == 274);
	11489	try expect(v[18] == 275);
	11490	try expect(v[19] == 276);
	11491	try expect(v[20] == 277);
	11492	try expect(v[21] == 278);
	11493	try expect(v[22] == 279);
	11494	try expect(v[23] == 280);
	11495	c_vector_24_u32(.{
	11496	281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
	11497	297, 298, 299, 300, 301, 302, 303, 304,
	11498	}, 24);
	11499	c_test_vector_24_u32();
	11500	}
	11501
	11502	export fn zig_ret_vector_32_u32() @Vector(32, u32) {
	11503	return .{
	11504	305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
	11505	321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
	11506	};
	11507	}
	11508	export fn zig_vector_32_u32(v: @Vector(32, u32), i: usize) void {
	11509	expect(v[0] == 337) catch @panic("test failure");
	11510	expect(v[1] == 338) catch @panic("test failure");
	11511	expect(v[2] == 339) catch @panic("test failure");
	11512	expect(v[3] == 340) catch @panic("test failure");
	11513	expect(v[4] == 341) catch @panic("test failure");
	11514	expect(v[5] == 342) catch @panic("test failure");
	11515	expect(v[6] == 343) catch @panic("test failure");
	11516	expect(v[7] == 344) catch @panic("test failure");
	11517	expect(v[8] == 345) catch @panic("test failure");
	11518	expect(v[9] == 346) catch @panic("test failure");
	11519	expect(v[10] == 347) catch @panic("test failure");
	11520	expect(v[11] == 348) catch @panic("test failure");
	11521	expect(v[12] == 349) catch @panic("test failure");
	11522	expect(v[13] == 350) catch @panic("test failure");
	11523	expect(v[14] == 351) catch @panic("test failure");
	11524	expect(v[15] == 352) catch @panic("test failure");
	11525	expect(v[16] == 353) catch @panic("test failure");
	11526	expect(v[17] == 354) catch @panic("test failure");
	11527	expect(v[18] == 355) catch @panic("test failure");
	11528	expect(v[19] == 356) catch @panic("test failure");
	11529	expect(v[20] == 357) catch @panic("test failure");
	11530	expect(v[21] == 358) catch @panic("test failure");
	11531	expect(v[22] == 359) catch @panic("test failure");
	11532	expect(v[23] == 360) catch @panic("test failure");
	11533	expect(v[24] == 361) catch @panic("test failure");
	11534	expect(v[25] == 362) catch @panic("test failure");
	11535	expect(v[26] == 363) catch @panic("test failure");
	11536	expect(v[27] == 364) catch @panic("test failure");
	11537	expect(v[28] == 365) catch @panic("test failure");
	11538	expect(v[29] == 366) catch @panic("test failure");
	11539	expect(v[30] == 367) catch @panic("test failure");
	11540	expect(v[31] == 368) catch @panic("test failure");
	11541	expect(i == 32) catch @panic("test failure");
	11542	}
	11543
	11544	extern fn c_ret_vector_32_u32() @Vector(32, u32);
	11545	extern fn c_vector_32_u32(@Vector(32, u32), usize) void;
	11546	extern fn c_test_vector_32_u32() void;
	11547
	11548	test "@Vector(32, u32)" {
	11549	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	11550	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	11551	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	11552	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	11553	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	11554
	11555	const v = c_ret_vector_32_u32();
	11556	try expect(v[0] == 369);
	11557	try expect(v[1] == 370);
	11558	try expect(v[2] == 371);
	11559	try expect(v[3] == 372);
	11560	try expect(v[4] == 373);
	11561	try expect(v[5] == 374);
	11562	try expect(v[6] == 375);
	11563	try expect(v[7] == 376);
	11564	try expect(v[8] == 377);
	11565	try expect(v[9] == 378);
	11566	try expect(v[10] == 379);
	11567	try expect(v[11] == 380);
	11568	try expect(v[12] == 381);
	11569	try expect(v[13] == 382);
	11570	try expect(v[14] == 383);
	11571	try expect(v[15] == 384);
	11572	try expect(v[16] == 385);
	11573	try expect(v[17] == 386);
	11574	try expect(v[18] == 387);
	11575	try expect(v[19] == 388);
	11576	try expect(v[20] == 389);
	11577	try expect(v[21] == 390);
	11578	try expect(v[22] == 391);
	11579	try expect(v[23] == 392);
	11580	try expect(v[24] == 393);
	11581	try expect(v[25] == 394);
	11582	try expect(v[26] == 395);
	11583	try expect(v[27] == 396);
	11584	try expect(v[28] == 397);
	11585	try expect(v[29] == 398);
	11586	try expect(v[30] == 399);
	11587	try expect(v[31] == 400);
	11588	c_vector_32_u32(.{
	11589	401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416,
	11590	417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432,
	11591	}, 32);
	11592	c_test_vector_32_u32();
	11593	}
	11594
	11595	export fn zig_ret_vector_48_u32() @Vector(48, u32) {
	11596	return .{
	11597	433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448,
	11598	449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
	11599	465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,
	11600	};
	11601	}
	11602	export fn zig_vector_48_u32(v: @Vector(48, u32), i: usize) void {
	11603	expect(v[0] == 481) catch @panic("test failure");
	11604	expect(v[1] == 482) catch @panic("test failure");
	11605	expect(v[2] == 483) catch @panic("test failure");
	11606	expect(v[3] == 484) catch @panic("test failure");
	11607	expect(v[4] == 485) catch @panic("test failure");
	11608	expect(v[5] == 486) catch @panic("test failure");
	11609	expect(v[6] == 487) catch @panic("test failure");
	11610	expect(v[7] == 488) catch @panic("test failure");
	11611	expect(v[8] == 489) catch @panic("test failure");
	11612	expect(v[9] == 490) catch @panic("test failure");
	11613	expect(v[10] == 491) catch @panic("test failure");
	11614	expect(v[11] == 492) catch @panic("test failure");
	11615	expect(v[12] == 493) catch @panic("test failure");
	11616	expect(v[13] == 494) catch @panic("test failure");
	11617	expect(v[14] == 495) catch @panic("test failure");
	11618	expect(v[15] == 496) catch @panic("test failure");
	11619	expect(v[16] == 497) catch @panic("test failure");
	11620	expect(v[17] == 498) catch @panic("test failure");
	11621	expect(v[18] == 499) catch @panic("test failure");
	11622	expect(v[19] == 500) catch @panic("test failure");
	11623	expect(v[20] == 501) catch @panic("test failure");
	11624	expect(v[21] == 502) catch @panic("test failure");
	11625	expect(v[22] == 503) catch @panic("test failure");
	11626	expect(v[23] == 504) catch @panic("test failure");
	11627	expect(v[24] == 505) catch @panic("test failure");
	11628	expect(v[25] == 506) catch @panic("test failure");
	11629	expect(v[26] == 507) catch @panic("test failure");
	11630	expect(v[27] == 508) catch @panic("test failure");
	11631	expect(v[28] == 509) catch @panic("test failure");
	11632	expect(v[29] == 510) catch @panic("test failure");
	11633	expect(v[30] == 511) catch @panic("test failure");
	11634	expect(v[31] == 512) catch @panic("test failure");
	11635	expect(v[32] == 513) catch @panic("test failure");
	11636	expect(v[33] == 514) catch @panic("test failure");
	11637	expect(v[34] == 515) catch @panic("test failure");
	11638	expect(v[35] == 516) catch @panic("test failure");
	11639	expect(v[36] == 517) catch @panic("test failure");
	11640	expect(v[37] == 518) catch @panic("test failure");
	11641	expect(v[38] == 519) catch @panic("test failure");
	11642	expect(v[39] == 520) catch @panic("test failure");
	11643	expect(v[40] == 521) catch @panic("test failure");
	11644	expect(v[41] == 522) catch @panic("test failure");
	11645	expect(v[42] == 523) catch @panic("test failure");
	11646	expect(v[43] == 524) catch @panic("test failure");
	11647	expect(v[44] == 525) catch @panic("test failure");
	11648	expect(v[45] == 526) catch @panic("test failure");
	11649	expect(v[46] == 527) catch @panic("test failure");
	11650	expect(v[47] == 528) catch @panic("test failure");
	11651	expect(i == 48) catch @panic("test failure");
	11652	}
	11653
	11654	extern fn c_ret_vector_48_u32() @Vector(48, u32);
	11655	extern fn c_vector_48_u32(@Vector(48, u32), usize) void;
	11656	extern fn c_test_vector_48_u32() void;
	11657
	11658	test "@Vector(48, u32)" {
	11659	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	11660	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	11661	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	11662	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	11663	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	11664
	11665	const v = c_ret_vector_48_u32();
	11666	try expect(v[0] == 529);
	11667	try expect(v[1] == 530);
	11668	try expect(v[2] == 531);
	11669	try expect(v[3] == 532);
	11670	try expect(v[4] == 533);
	11671	try expect(v[5] == 534);
	11672	try expect(v[6] == 535);
	11673	try expect(v[7] == 536);
	11674	try expect(v[8] == 537);
	11675	try expect(v[9] == 538);
	11676	try expect(v[10] == 539);
	11677	try expect(v[11] == 540);
	11678	try expect(v[12] == 541);
	11679	try expect(v[13] == 542);
	11680	try expect(v[14] == 543);
	11681	try expect(v[15] == 544);
	11682	try expect(v[16] == 545);
	11683	try expect(v[17] == 546);
	11684	try expect(v[18] == 547);
	11685	try expect(v[19] == 548);
	11686	try expect(v[20] == 549);
	11687	try expect(v[21] == 550);
	11688	try expect(v[22] == 551);
	11689	try expect(v[23] == 552);
	11690	try expect(v[24] == 553);
	11691	try expect(v[25] == 554);
	11692	try expect(v[26] == 555);
	11693	try expect(v[27] == 556);
	11694	try expect(v[28] == 557);
	11695	try expect(v[29] == 558);
	11696	try expect(v[30] == 559);
	11697	try expect(v[31] == 560);
	11698	try expect(v[32] == 561);
	11699	try expect(v[33] == 562);
	11700	try expect(v[34] == 563);
	11701	try expect(v[35] == 564);
	11702	try expect(v[36] == 565);
	11703	try expect(v[37] == 566);
	11704	try expect(v[38] == 567);
	11705	try expect(v[39] == 568);
	11706	try expect(v[40] == 569);
	11707	try expect(v[41] == 570);
	11708	try expect(v[42] == 571);
	11709	try expect(v[43] == 572);
	11710	try expect(v[44] == 573);
	11711	try expect(v[45] == 574);
	11712	try expect(v[46] == 575);
	11713	try expect(v[47] == 576);
	11714	c_vector_48_u32(.{
	11715	577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
	11716	593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,
	11717	609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
	11718	}, 48);
	11719	c_test_vector_48_u32();
	11720	}
	11721
	11722	export fn zig_ret_vector_64_u32() @Vector(64, u32) {
	11723	return .{
	11724	625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640,
	11725	641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656,
	11726	657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672,
	11727	673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688,
	11728	};
	11729	}
	11730	export fn zig_vector_64_u32(v: @Vector(64, u32), i: usize) void {
	11731	expect(v[0] == 689) catch @panic("test failure");
	11732	expect(v[1] == 690) catch @panic("test failure");
	11733	expect(v[2] == 691) catch @panic("test failure");
	11734	expect(v[3] == 692) catch @panic("test failure");
	11735	expect(v[4] == 693) catch @panic("test failure");
	11736	expect(v[5] == 694) catch @panic("test failure");
	11737	expect(v[6] == 695) catch @panic("test failure");
	11738	expect(v[7] == 696) catch @panic("test failure");
	11739	expect(v[8] == 697) catch @panic("test failure");
	11740	expect(v[9] == 698) catch @panic("test failure");
	11741	expect(v[10] == 699) catch @panic("test failure");
	11742	expect(v[11] == 700) catch @panic("test failure");
	11743	expect(v[12] == 701) catch @panic("test failure");
	11744	expect(v[13] == 702) catch @panic("test failure");
	11745	expect(v[14] == 703) catch @panic("test failure");
	11746	expect(v[15] == 704) catch @panic("test failure");
	11747	expect(v[16] == 705) catch @panic("test failure");
	11748	expect(v[17] == 706) catch @panic("test failure");
	11749	expect(v[18] == 707) catch @panic("test failure");
	11750	expect(v[19] == 708) catch @panic("test failure");
	11751	expect(v[20] == 709) catch @panic("test failure");
	11752	expect(v[21] == 710) catch @panic("test failure");
	11753	expect(v[22] == 711) catch @panic("test failure");
	11754	expect(v[23] == 712) catch @panic("test failure");
	11755	expect(v[24] == 713) catch @panic("test failure");
	11756	expect(v[25] == 714) catch @panic("test failure");
	11757	expect(v[26] == 715) catch @panic("test failure");
	11758	expect(v[27] == 716) catch @panic("test failure");
	11759	expect(v[28] == 717) catch @panic("test failure");
	11760	expect(v[29] == 718) catch @panic("test failure");
	11761	expect(v[30] == 719) catch @panic("test failure");
	11762	expect(v[31] == 720) catch @panic("test failure");
	11763	expect(v[32] == 721) catch @panic("test failure");
	11764	expect(v[33] == 722) catch @panic("test failure");
	11765	expect(v[34] == 723) catch @panic("test failure");
	11766	expect(v[35] == 724) catch @panic("test failure");
	11767	expect(v[36] == 725) catch @panic("test failure");
	11768	expect(v[37] == 726) catch @panic("test failure");
	11769	expect(v[38] == 727) catch @panic("test failure");
	11770	expect(v[39] == 728) catch @panic("test failure");
	11771	expect(v[40] == 729) catch @panic("test failure");
	11772	expect(v[41] == 730) catch @panic("test failure");
	11773	expect(v[42] == 731) catch @panic("test failure");
	11774	expect(v[43] == 732) catch @panic("test failure");
	11775	expect(v[44] == 733) catch @panic("test failure");
	11776	expect(v[45] == 734) catch @panic("test failure");
	11777	expect(v[46] == 735) catch @panic("test failure");
	11778	expect(v[47] == 736) catch @panic("test failure");
	11779	expect(v[48] == 737) catch @panic("test failure");
	11780	expect(v[49] == 738) catch @panic("test failure");
	11781	expect(v[50] == 739) catch @panic("test failure");
	11782	expect(v[51] == 740) catch @panic("test failure");
	11783	expect(v[52] == 741) catch @panic("test failure");
	11784	expect(v[53] == 742) catch @panic("test failure");
	11785	expect(v[54] == 743) catch @panic("test failure");
	11786	expect(v[55] == 744) catch @panic("test failure");
	11787	expect(v[56] == 745) catch @panic("test failure");
	11788	expect(v[57] == 746) catch @panic("test failure");
	11789	expect(v[58] == 747) catch @panic("test failure");
	11790	expect(v[59] == 748) catch @panic("test failure");
	11791	expect(v[60] == 749) catch @panic("test failure");
	11792	expect(v[61] == 750) catch @panic("test failure");
	11793	expect(v[62] == 751) catch @panic("test failure");
	11794	expect(v[63] == 752) catch @panic("test failure");
	11795	expect(i == 64) catch @panic("test failure");
	11796	}
	11797
	11798	extern fn c_ret_vector_64_u32() @Vector(64, u32);
	11799	extern fn c_vector_64_u32(@Vector(64, u32), usize) void;
	11800	extern fn c_test_vector_64_u32() void;
	11801
	11802	test "@Vector(64, u32)" {
	11803	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	11804	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	11805	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	11806	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	11807	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	11808
	11809	const v = c_ret_vector_64_u32();
	11810	try expect(v[0] == 753);
	11811	try expect(v[1] == 754);
	11812	try expect(v[2] == 755);
	11813	try expect(v[3] == 756);
	11814	try expect(v[4] == 757);
	11815	try expect(v[5] == 758);
	11816	try expect(v[6] == 759);
	11817	try expect(v[7] == 760);
	11818	try expect(v[8] == 761);
	11819	try expect(v[9] == 762);
	11820	try expect(v[10] == 763);
	11821	try expect(v[11] == 764);
	11822	try expect(v[12] == 765);
	11823	try expect(v[13] == 766);
	11824	try expect(v[14] == 767);
	11825	try expect(v[15] == 768);
	11826	try expect(v[16] == 769);
	11827	try expect(v[17] == 770);
	11828	try expect(v[18] == 771);
	11829	try expect(v[19] == 772);
	11830	try expect(v[20] == 773);
	11831	try expect(v[21] == 774);
	11832	try expect(v[22] == 775);
	11833	try expect(v[23] == 776);
	11834	try expect(v[24] == 777);
	11835	try expect(v[25] == 778);
	11836	try expect(v[26] == 779);
	11837	try expect(v[27] == 780);
	11838	try expect(v[28] == 781);
	11839	try expect(v[29] == 782);
	11840	try expect(v[30] == 783);
	11841	try expect(v[31] == 784);
	11842	try expect(v[32] == 785);
	11843	try expect(v[33] == 786);
	11844	try expect(v[34] == 787);
	11845	try expect(v[35] == 788);
	11846	try expect(v[36] == 789);
	11847	try expect(v[37] == 790);
	11848	try expect(v[38] == 791);
	11849	try expect(v[39] == 792);
	11850	try expect(v[40] == 793);
	11851	try expect(v[41] == 794);
	11852	try expect(v[42] == 795);
	11853	try expect(v[43] == 796);
	11854	try expect(v[44] == 797);
	11855	try expect(v[45] == 798);
	11856	try expect(v[46] == 799);
	11857	try expect(v[47] == 800);
	11858	try expect(v[48] == 801);
	11859	try expect(v[49] == 802);
	11860	try expect(v[50] == 803);
	11861	try expect(v[51] == 804);
	11862	try expect(v[52] == 805);
	11863	try expect(v[53] == 806);
	11864	try expect(v[54] == 807);
	11865	try expect(v[55] == 808);
	11866	try expect(v[56] == 809);
	11867	try expect(v[57] == 810);
	11868	try expect(v[58] == 811);
	11869	try expect(v[59] == 812);
	11870	try expect(v[60] == 813);
	11871	try expect(v[61] == 814);
	11872	try expect(v[62] == 815);
	11873	try expect(v[63] == 816);
	11874	c_vector_64_u32(.{
	11875	817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832,
	11876	833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848,
	11877	849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864,
	11878	865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880,
	11879	}, 64);
	11880	c_test_vector_64_u32();
	11881	}
	11882
	11883	export fn zig_ret_vector_96_u32() @Vector(96, u32) {
	11884	return .{
	11885	890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905,
	11886	906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921,
	11887	922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937,
	11888	938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953,
	11889	954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969,
	11890	970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985,
	11891	};
	11892	}
	11893	export fn zig_vector_96_u32(v: @Vector(96, u32), i: usize) void {
	11894	expect(v[0] == 986) catch @panic("test failure");
	11895	expect(v[1] == 987) catch @panic("test failure");
	11896	expect(v[2] == 988) catch @panic("test failure");
	11897	expect(v[3] == 989) catch @panic("test failure");
	11898	expect(v[4] == 990) catch @panic("test failure");
	11899	expect(v[5] == 991) catch @panic("test failure");
	11900	expect(v[6] == 992) catch @panic("test failure");
	11901	expect(v[7] == 993) catch @panic("test failure");
	11902	expect(v[8] == 994) catch @panic("test failure");
	11903	expect(v[9] == 995) catch @panic("test failure");
	11904	expect(v[10] == 996) catch @panic("test failure");
	11905	expect(v[11] == 997) catch @panic("test failure");
	11906	expect(v[12] == 998) catch @panic("test failure");
	11907	expect(v[13] == 999) catch @panic("test failure");
	11908	expect(v[14] == 1000) catch @panic("test failure");
	11909	expect(v[15] == 1001) catch @panic("test failure");
	11910	expect(v[16] == 1002) catch @panic("test failure");
	11911	expect(v[17] == 1003) catch @panic("test failure");
	11912	expect(v[18] == 1004) catch @panic("test failure");
	11913	expect(v[19] == 1005) catch @panic("test failure");
	11914	expect(v[20] == 1006) catch @panic("test failure");
	11915	expect(v[21] == 1007) catch @panic("test failure");
	11916	expect(v[22] == 1008) catch @panic("test failure");
	11917	expect(v[23] == 1009) catch @panic("test failure");
	11918	expect(v[24] == 1010) catch @panic("test failure");
	11919	expect(v[25] == 1011) catch @panic("test failure");
	11920	expect(v[26] == 1012) catch @panic("test failure");
	11921	expect(v[27] == 1013) catch @panic("test failure");
	11922	expect(v[28] == 1014) catch @panic("test failure");
	11923	expect(v[29] == 1015) catch @panic("test failure");
	11924	expect(v[30] == 1016) catch @panic("test failure");
	11925	expect(v[31] == 1017) catch @panic("test failure");
	11926	expect(v[32] == 1018) catch @panic("test failure");
	11927	expect(v[33] == 1019) catch @panic("test failure");
	11928	expect(v[34] == 1020) catch @panic("test failure");
	11929	expect(v[35] == 1021) catch @panic("test failure");
	11930	expect(v[36] == 1022) catch @panic("test failure");
	11931	expect(v[37] == 1023) catch @panic("test failure");
	11932	expect(v[38] == 1024) catch @panic("test failure");
	11933	expect(v[39] == 1025) catch @panic("test failure");
	11934	expect(v[40] == 1026) catch @panic("test failure");
	11935	expect(v[41] == 1027) catch @panic("test failure");
	11936	expect(v[42] == 1028) catch @panic("test failure");
	11937	expect(v[43] == 1029) catch @panic("test failure");
	11938	expect(v[44] == 1030) catch @panic("test failure");
	11939	expect(v[45] == 1031) catch @panic("test failure");
	11940	expect(v[46] == 1032) catch @panic("test failure");
	11941	expect(v[47] == 1033) catch @panic("test failure");
	11942	expect(v[48] == 1034) catch @panic("test failure");
	11943	expect(v[49] == 1035) catch @panic("test failure");
	11944	expect(v[50] == 1036) catch @panic("test failure");
	11945	expect(v[51] == 1037) catch @panic("test failure");
	11946	expect(v[52] == 1038) catch @panic("test failure");
	11947	expect(v[53] == 1039) catch @panic("test failure");
	11948	expect(v[54] == 1040) catch @panic("test failure");
	11949	expect(v[55] == 1041) catch @panic("test failure");
	11950	expect(v[56] == 1042) catch @panic("test failure");
	11951	expect(v[57] == 1043) catch @panic("test failure");
	11952	expect(v[58] == 1044) catch @panic("test failure");
	11953	expect(v[59] == 1045) catch @panic("test failure");
	11954	expect(v[60] == 1046) catch @panic("test failure");
	11955	expect(v[61] == 1047) catch @panic("test failure");
	11956	expect(v[62] == 1048) catch @panic("test failure");
	11957	expect(v[63] == 1049) catch @panic("test failure");
	11958	expect(v[64] == 1050) catch @panic("test failure");
	11959	expect(v[65] == 1051) catch @panic("test failure");
	11960	expect(v[66] == 1052) catch @panic("test failure");
	11961	expect(v[67] == 1053) catch @panic("test failure");
	11962	expect(v[68] == 1054) catch @panic("test failure");
	11963	expect(v[69] == 1055) catch @panic("test failure");
	11964	expect(v[70] == 1056) catch @panic("test failure");
	11965	expect(v[71] == 1057) catch @panic("test failure");
	11966	expect(v[72] == 1058) catch @panic("test failure");
	11967	expect(v[73] == 1059) catch @panic("test failure");
	11968	expect(v[74] == 1060) catch @panic("test failure");
	11969	expect(v[75] == 1061) catch @panic("test failure");
	11970	expect(v[76] == 1062) catch @panic("test failure");
	11971	expect(v[77] == 1063) catch @panic("test failure");
	11972	expect(v[78] == 1064) catch @panic("test failure");
	11973	expect(v[79] == 1065) catch @panic("test failure");
	11974	expect(v[80] == 1066) catch @panic("test failure");
	11975	expect(v[81] == 1067) catch @panic("test failure");
	11976	expect(v[82] == 1068) catch @panic("test failure");
	11977	expect(v[83] == 1069) catch @panic("test failure");
	11978	expect(v[84] == 1070) catch @panic("test failure");
	11979	expect(v[85] == 1071) catch @panic("test failure");
	11980	expect(v[86] == 1072) catch @panic("test failure");
	11981	expect(v[87] == 1073) catch @panic("test failure");
	11982	expect(v[88] == 1074) catch @panic("test failure");
	11983	expect(v[89] == 1075) catch @panic("test failure");
	11984	expect(v[90] == 1076) catch @panic("test failure");
	11985	expect(v[91] == 1077) catch @panic("test failure");
	11986	expect(v[92] == 1078) catch @panic("test failure");
	11987	expect(v[93] == 1079) catch @panic("test failure");
	11988	expect(v[94] == 1080) catch @panic("test failure");
	11989	expect(v[95] == 1081) catch @panic("test failure");
	11990	expect(i == 96) catch @panic("test failure");
	11991	}
	11992
	11993	extern fn c_ret_vector_96_u32() @Vector(96, u32);
	11994	extern fn c_vector_96_u32(@Vector(96, u32), usize) void;
	11995	extern fn c_test_vector_96_u32() void;
	11996
	11997	test "@Vector(96, u32)" {
	11998	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	11999	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	12000	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	12001	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	12002	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	12003
	12004	const v = c_ret_vector_96_u32();
	12005	try expect(v[0] == 1082);
	12006	try expect(v[1] == 1083);
	12007	try expect(v[2] == 1084);
	12008	try expect(v[3] == 1085);
	12009	try expect(v[4] == 1086);
	12010	try expect(v[5] == 1087);
	12011	try expect(v[6] == 1088);
	12012	try expect(v[7] == 1089);
	12013	try expect(v[8] == 1090);
	12014	try expect(v[9] == 1091);
	12015	try expect(v[10] == 1092);
	12016	try expect(v[11] == 1093);
	12017	try expect(v[12] == 1094);
	12018	try expect(v[13] == 1095);
	12019	try expect(v[14] == 1096);
	12020	try expect(v[15] == 1097);
	12021	try expect(v[16] == 1098);
	12022	try expect(v[17] == 1099);
	12023	try expect(v[18] == 1100);
	12024	try expect(v[19] == 1101);
	12025	try expect(v[20] == 1102);
	12026	try expect(v[21] == 1103);
	12027	try expect(v[22] == 1104);
	12028	try expect(v[23] == 1105);
	12029	try expect(v[24] == 1106);
	12030	try expect(v[25] == 1107);
	12031	try expect(v[26] == 1108);
	12032	try expect(v[27] == 1109);
	12033	try expect(v[28] == 1110);
	12034	try expect(v[29] == 1111);
	12035	try expect(v[30] == 1112);
	12036	try expect(v[31] == 1113);
	12037	try expect(v[32] == 1114);
	12038	try expect(v[33] == 1115);
	12039	try expect(v[34] == 1116);
	12040	try expect(v[35] == 1117);
	12041	try expect(v[36] == 1118);
	12042	try expect(v[37] == 1119);
	12043	try expect(v[38] == 1120);
	12044	try expect(v[39] == 1121);
	12045	try expect(v[40] == 1122);
	12046	try expect(v[41] == 1123);
	12047	try expect(v[42] == 1124);
	12048	try expect(v[43] == 1125);
	12049	try expect(v[44] == 1126);
	12050	try expect(v[45] == 1127);
	12051	try expect(v[46] == 1128);
	12052	try expect(v[47] == 1129);
	12053	try expect(v[48] == 1130);
	12054	try expect(v[49] == 1131);
	12055	try expect(v[50] == 1132);
	12056	try expect(v[51] == 1133);
	12057	try expect(v[52] == 1134);
	12058	try expect(v[53] == 1135);
	12059	try expect(v[54] == 1136);
	12060	try expect(v[55] == 1137);
	12061	try expect(v[56] == 1138);
	12062	try expect(v[57] == 1139);
	12063	try expect(v[58] == 1140);
	12064	try expect(v[59] == 1141);
	12065	try expect(v[60] == 1142);
	12066	try expect(v[61] == 1143);
	12067	try expect(v[62] == 1144);
	12068	try expect(v[63] == 1145);
	12069	try expect(v[64] == 1146);
	12070	try expect(v[65] == 1147);
	12071	try expect(v[66] == 1148);
	12072	try expect(v[67] == 1149);
	12073	try expect(v[68] == 1150);
	12074	try expect(v[69] == 1151);
	12075	try expect(v[70] == 1152);
	12076	try expect(v[71] == 1153);
	12077	try expect(v[72] == 1154);
	12078	try expect(v[73] == 1155);
	12079	try expect(v[74] == 1156);
	12080	try expect(v[75] == 1157);
	12081	try expect(v[76] == 1158);
	12082	try expect(v[77] == 1159);
	12083	try expect(v[78] == 1160);
	12084	try expect(v[79] == 1161);
	12085	try expect(v[80] == 1162);
	12086	try expect(v[81] == 1163);
	12087	try expect(v[82] == 1164);
	12088	try expect(v[83] == 1165);
	12089	try expect(v[84] == 1166);
	12090	try expect(v[85] == 1167);
	12091	try expect(v[86] == 1168);
	12092	try expect(v[87] == 1169);
	12093	try expect(v[88] == 1170);
	12094	try expect(v[89] == 1171);
	12095	try expect(v[90] == 1172);
	12096	try expect(v[91] == 1173);
	12097	try expect(v[92] == 1174);
	12098	try expect(v[93] == 1175);
	12099	try expect(v[94] == 1176);
	12100	try expect(v[95] == 1177);
	12101	c_vector_96_u32(.{
	12102	1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193,
	12103	1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209,
	12104	1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225,
	12105	1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241,
	12106	1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257,
	12107	1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273,
	12108	}, 96);
	12109	c_test_vector_96_u32();
	12110	}
	12111
	12112	export fn zig_ret_vector_128_u32() @Vector(128, u32) {
	12113	return .{
	12114	1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289,
	12115	1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305,
	12116	1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321,
	12117	1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337,
	12118	1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353,
	12119	1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369,
	12120	1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385,
	12121	1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401,
	12122	};
	12123	}
	12124	export fn zig_vector_128_u32(v: @Vector(128, u32), i: usize) void {
	12125	expect(v[0] == 1402) catch @panic("test failure");
	12126	expect(v[1] == 1403) catch @panic("test failure");
	12127	expect(v[2] == 1404) catch @panic("test failure");
	12128	expect(v[3] == 1405) catch @panic("test failure");
	12129	expect(v[4] == 1406) catch @panic("test failure");
	12130	expect(v[5] == 1407) catch @panic("test failure");
	12131	expect(v[6] == 1408) catch @panic("test failure");
	12132	expect(v[7] == 1409) catch @panic("test failure");
	12133	expect(v[8] == 1410) catch @panic("test failure");
	12134	expect(v[9] == 1411) catch @panic("test failure");
	12135	expect(v[10] == 1412) catch @panic("test failure");
	12136	expect(v[11] == 1413) catch @panic("test failure");
	12137	expect(v[12] == 1414) catch @panic("test failure");
	12138	expect(v[13] == 1415) catch @panic("test failure");
	12139	expect(v[14] == 1416) catch @panic("test failure");
	12140	expect(v[15] == 1417) catch @panic("test failure");
	12141	expect(v[16] == 1418) catch @panic("test failure");
	12142	expect(v[17] == 1419) catch @panic("test failure");
	12143	expect(v[18] == 1420) catch @panic("test failure");
	12144	expect(v[19] == 1421) catch @panic("test failure");
	12145	expect(v[20] == 1422) catch @panic("test failure");
	12146	expect(v[21] == 1423) catch @panic("test failure");
	12147	expect(v[22] == 1424) catch @panic("test failure");
	12148	expect(v[23] == 1425) catch @panic("test failure");
	12149	expect(v[24] == 1426) catch @panic("test failure");
	12150	expect(v[25] == 1427) catch @panic("test failure");
	12151	expect(v[26] == 1428) catch @panic("test failure");
	12152	expect(v[27] == 1429) catch @panic("test failure");
	12153	expect(v[28] == 1430) catch @panic("test failure");
	12154	expect(v[29] == 1431) catch @panic("test failure");
	12155	expect(v[30] == 1432) catch @panic("test failure");
	12156	expect(v[31] == 1433) catch @panic("test failure");
	12157	expect(v[32] == 1434) catch @panic("test failure");
	12158	expect(v[33] == 1435) catch @panic("test failure");
	12159	expect(v[34] == 1436) catch @panic("test failure");
	12160	expect(v[35] == 1437) catch @panic("test failure");
	12161	expect(v[36] == 1438) catch @panic("test failure");
	12162	expect(v[37] == 1439) catch @panic("test failure");
	12163	expect(v[38] == 1440) catch @panic("test failure");
	12164	expect(v[39] == 1441) catch @panic("test failure");
	12165	expect(v[40] == 1442) catch @panic("test failure");
	12166	expect(v[41] == 1443) catch @panic("test failure");
	12167	expect(v[42] == 1444) catch @panic("test failure");
	12168	expect(v[43] == 1445) catch @panic("test failure");
	12169	expect(v[44] == 1446) catch @panic("test failure");
	12170	expect(v[45] == 1447) catch @panic("test failure");
	12171	expect(v[46] == 1448) catch @panic("test failure");
	12172	expect(v[47] == 1449) catch @panic("test failure");
	12173	expect(v[48] == 1450) catch @panic("test failure");
	12174	expect(v[49] == 1451) catch @panic("test failure");
	12175	expect(v[50] == 1452) catch @panic("test failure");
	12176	expect(v[51] == 1453) catch @panic("test failure");
	12177	expect(v[52] == 1454) catch @panic("test failure");
	12178	expect(v[53] == 1455) catch @panic("test failure");
	12179	expect(v[54] == 1456) catch @panic("test failure");
	12180	expect(v[55] == 1457) catch @panic("test failure");
	12181	expect(v[56] == 1458) catch @panic("test failure");
	12182	expect(v[57] == 1459) catch @panic("test failure");
	12183	expect(v[58] == 1460) catch @panic("test failure");
	12184	expect(v[59] == 1461) catch @panic("test failure");
	12185	expect(v[60] == 1462) catch @panic("test failure");
	12186	expect(v[61] == 1463) catch @panic("test failure");
	12187	expect(v[62] == 1464) catch @panic("test failure");
	12188	expect(v[63] == 1465) catch @panic("test failure");
	12189	expect(v[64] == 1466) catch @panic("test failure");
	12190	expect(v[65] == 1467) catch @panic("test failure");
	12191	expect(v[66] == 1468) catch @panic("test failure");
	12192	expect(v[67] == 1469) catch @panic("test failure");
	12193	expect(v[68] == 1470) catch @panic("test failure");
	12194	expect(v[69] == 1471) catch @panic("test failure");
	12195	expect(v[70] == 1472) catch @panic("test failure");
	12196	expect(v[71] == 1473) catch @panic("test failure");
	12197	expect(v[72] == 1474) catch @panic("test failure");
	12198	expect(v[73] == 1475) catch @panic("test failure");
	12199	expect(v[74] == 1476) catch @panic("test failure");
	12200	expect(v[75] == 1477) catch @panic("test failure");
	12201	expect(v[76] == 1478) catch @panic("test failure");
	12202	expect(v[77] == 1479) catch @panic("test failure");
	12203	expect(v[78] == 1480) catch @panic("test failure");
	12204	expect(v[79] == 1481) catch @panic("test failure");
	12205	expect(v[80] == 1482) catch @panic("test failure");
	12206	expect(v[81] == 1483) catch @panic("test failure");
	12207	expect(v[82] == 1484) catch @panic("test failure");
	12208	expect(v[83] == 1485) catch @panic("test failure");
	12209	expect(v[84] == 1486) catch @panic("test failure");
	12210	expect(v[85] == 1487) catch @panic("test failure");
	12211	expect(v[86] == 1488) catch @panic("test failure");
	12212	expect(v[87] == 1489) catch @panic("test failure");
	12213	expect(v[88] == 1490) catch @panic("test failure");
	12214	expect(v[89] == 1491) catch @panic("test failure");
	12215	expect(v[90] == 1492) catch @panic("test failure");
	12216	expect(v[91] == 1493) catch @panic("test failure");
	12217	expect(v[92] == 1494) catch @panic("test failure");
	12218	expect(v[93] == 1495) catch @panic("test failure");
	12219	expect(v[94] == 1496) catch @panic("test failure");
	12220	expect(v[95] == 1497) catch @panic("test failure");
	12221	expect(v[96] == 1498) catch @panic("test failure");
	12222	expect(v[97] == 1499) catch @panic("test failure");
	12223	expect(v[98] == 1500) catch @panic("test failure");
	12224	expect(v[99] == 1501) catch @panic("test failure");
	12225	expect(v[100] == 1502) catch @panic("test failure");
	12226	expect(v[101] == 1503) catch @panic("test failure");
	12227	expect(v[102] == 1504) catch @panic("test failure");
	12228	expect(v[103] == 1505) catch @panic("test failure");
	12229	expect(v[104] == 1506) catch @panic("test failure");
	12230	expect(v[105] == 1507) catch @panic("test failure");
	12231	expect(v[106] == 1508) catch @panic("test failure");
	12232	expect(v[107] == 1509) catch @panic("test failure");
	12233	expect(v[108] == 1510) catch @panic("test failure");
	12234	expect(v[109] == 1511) catch @panic("test failure");
	12235	expect(v[110] == 1512) catch @panic("test failure");
	12236	expect(v[111] == 1513) catch @panic("test failure");
	12237	expect(v[112] == 1514) catch @panic("test failure");
	12238	expect(v[113] == 1515) catch @panic("test failure");
	12239	expect(v[114] == 1516) catch @panic("test failure");
	12240	expect(v[115] == 1517) catch @panic("test failure");
	12241	expect(v[116] == 1518) catch @panic("test failure");
	12242	expect(v[117] == 1519) catch @panic("test failure");
	12243	expect(v[118] == 1520) catch @panic("test failure");
	12244	expect(v[119] == 1521) catch @panic("test failure");
	12245	expect(v[120] == 1522) catch @panic("test failure");
	12246	expect(v[121] == 1523) catch @panic("test failure");
	12247	expect(v[122] == 1524) catch @panic("test failure");
	12248	expect(v[123] == 1525) catch @panic("test failure");
	12249	expect(v[124] == 1526) catch @panic("test failure");
	12250	expect(v[125] == 1527) catch @panic("test failure");
	12251	expect(v[126] == 1528) catch @panic("test failure");
	12252	expect(v[127] == 1529) catch @panic("test failure");
	12253	expect(i == 128) catch @panic("test failure");
	12254	}
	12255
	12256	extern fn c_ret_vector_128_u32() @Vector(128, u32);
	12257	extern fn c_vector_128_u32(@Vector(128, u32), usize) void;
	12258	extern fn c_test_vector_128_u32() void;
	12259
	12260	test "@Vector(128, u32)" {
	12261	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	12262	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	12263	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	12264	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	12265	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	12266
	12267	const v = c_ret_vector_128_u32();
	12268	try expect(v[0] == 1530);
	12269	try expect(v[1] == 1531);
	12270	try expect(v[2] == 1532);
	12271	try expect(v[3] == 1533);
	12272	try expect(v[4] == 1534);
	12273	try expect(v[5] == 1535);
	12274	try expect(v[6] == 1536);
	12275	try expect(v[7] == 1537);
	12276	try expect(v[8] == 1538);
	12277	try expect(v[9] == 1539);
	12278	try expect(v[10] == 1540);
	12279	try expect(v[11] == 1541);
	12280	try expect(v[12] == 1542);
	12281	try expect(v[13] == 1543);
	12282	try expect(v[14] == 1544);
	12283	try expect(v[15] == 1545);
	12284	try expect(v[16] == 1546);
	12285	try expect(v[17] == 1547);
	12286	try expect(v[18] == 1548);
	12287	try expect(v[19] == 1549);
	12288	try expect(v[20] == 1550);
	12289	try expect(v[21] == 1551);
	12290	try expect(v[22] == 1552);
	12291	try expect(v[23] == 1553);
	12292	try expect(v[24] == 1554);
	12293	try expect(v[25] == 1555);
	12294	try expect(v[26] == 1556);
	12295	try expect(v[27] == 1557);
	12296	try expect(v[28] == 1558);
	12297	try expect(v[29] == 1559);
	12298	try expect(v[30] == 1560);
	12299	try expect(v[31] == 1561);
	12300	try expect(v[32] == 1562);
	12301	try expect(v[33] == 1563);
	12302	try expect(v[34] == 1564);
	12303	try expect(v[35] == 1565);
	12304	try expect(v[36] == 1566);
	12305	try expect(v[37] == 1567);
	12306	try expect(v[38] == 1568);
	12307	try expect(v[39] == 1569);
	12308	try expect(v[40] == 1570);
	12309	try expect(v[41] == 1571);
	12310	try expect(v[42] == 1572);
	12311	try expect(v[43] == 1573);
	12312	try expect(v[44] == 1574);
	12313	try expect(v[45] == 1575);
	12314	try expect(v[46] == 1576);
	12315	try expect(v[47] == 1577);
	12316	try expect(v[48] == 1578);
	12317	try expect(v[49] == 1579);
	12318	try expect(v[50] == 1580);
	12319	try expect(v[51] == 1581);
	12320	try expect(v[52] == 1582);
	12321	try expect(v[53] == 1583);
	12322	try expect(v[54] == 1584);
	12323	try expect(v[55] == 1585);
	12324	try expect(v[56] == 1586);
	12325	try expect(v[57] == 1587);
	12326	try expect(v[58] == 1588);
	12327	try expect(v[59] == 1589);
	12328	try expect(v[60] == 1590);
	12329	try expect(v[61] == 1591);
	12330	try expect(v[62] == 1592);
	12331	try expect(v[63] == 1593);
	12332	try expect(v[64] == 1594);
	12333	try expect(v[65] == 1595);
	12334	try expect(v[66] == 1596);
	12335	try expect(v[67] == 1597);
	12336	try expect(v[68] == 1598);
	12337	try expect(v[69] == 1599);
	12338	try expect(v[70] == 1600);
	12339	try expect(v[71] == 1601);
	12340	try expect(v[72] == 1602);
	12341	try expect(v[73] == 1603);
	12342	try expect(v[74] == 1604);
	12343	try expect(v[75] == 1605);
	12344	try expect(v[76] == 1606);
	12345	try expect(v[77] == 1607);
	12346	try expect(v[78] == 1608);
	12347	try expect(v[79] == 1609);
	12348	try expect(v[80] == 1610);
	12349	try expect(v[81] == 1611);
	12350	try expect(v[82] == 1612);
	12351	try expect(v[83] == 1613);
	12352	try expect(v[84] == 1614);
	12353	try expect(v[85] == 1615);
	12354	try expect(v[86] == 1616);
	12355	try expect(v[87] == 1617);
	12356	try expect(v[88] == 1618);
	12357	try expect(v[89] == 1619);
	12358	try expect(v[90] == 1620);
	12359	try expect(v[91] == 1621);
	12360	try expect(v[92] == 1622);
	12361	try expect(v[93] == 1623);
	12362	try expect(v[94] == 1624);
	12363	try expect(v[95] == 1625);
	12364	try expect(v[96] == 1626);
	12365	try expect(v[97] == 1627);
	12366	try expect(v[98] == 1628);
	12367	try expect(v[99] == 1629);
	12368	try expect(v[100] == 1630);
	12369	try expect(v[101] == 1631);
	12370	try expect(v[102] == 1632);
	12371	try expect(v[103] == 1633);
	12372	try expect(v[104] == 1634);
	12373	try expect(v[105] == 1635);
	12374	try expect(v[106] == 1636);
	12375	try expect(v[107] == 1637);
	12376	try expect(v[108] == 1638);
	12377	try expect(v[109] == 1639);
	12378	try expect(v[110] == 1640);
	12379	try expect(v[111] == 1641);
	12380	try expect(v[112] == 1642);
	12381	try expect(v[113] == 1643);
	12382	try expect(v[114] == 1644);
	12383	try expect(v[115] == 1645);
	12384	try expect(v[116] == 1646);
	12385	try expect(v[117] == 1647);
	12386	try expect(v[118] == 1648);
	12387	try expect(v[119] == 1649);
	12388	try expect(v[120] == 1650);
	12389	try expect(v[121] == 1651);
	12390	try expect(v[122] == 1652);
	12391	try expect(v[123] == 1653);
	12392	try expect(v[124] == 1654);
	12393	try expect(v[125] == 1655);
	12394	try expect(v[126] == 1656);
	12395	try expect(v[127] == 1657);
	12396	c_vector_128_u32(.{
	12397	1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673,
	12398	1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689,
	12399	1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705,
	12400	1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721,
	12401	1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737,
	12402	1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753,
	12403	1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769,
	12404	1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785,
	12405	}, 128);
	12406	c_test_vector_128_u32();
	12407	}
	12408
	12409	export fn zig_ret_vector_1_u64() @Vector(1, u64) {
	12410	return .{1};
	12411	}
	12412	export fn zig_vector_1_u64(v: @Vector(1, u64), i: usize) void {
	12413	expect(v[0] == 2) catch @panic("test failure");
	12414	expect(i == 1) catch @panic("test failure");
	12415	}
	12416
	12417	extern fn c_ret_vector_1_u64() @Vector(1, u64);
	12418	extern fn c_vector_1_u64(@Vector(1, u64), usize) void;
	12419	extern fn c_test_vector_1_u64() void;
	12420
	12421	test "@Vector(1, u64)" {
	12422	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag != .windows) return error.SkipZigTest;
	12423
	12424	const v = c_ret_vector_1_u64();
	12425	try expect(v[0] == 3);
	12426	c_vector_1_u64(.{4}, 1);
	12427	c_test_vector_1_u64();
	12428	}
	12429
	12430	export fn zig_ret_vector_2_u64() @Vector(2, u64) {
	12431	return .{ 5, 6 };
	12432	}
	12433	export fn zig_vector_2_u64(v: @Vector(2, u64), i: usize) void {
	12434	expect(v[0] == 7) catch @panic("test failure");
	12435	expect(v[1] == 8) catch @panic("test failure");
	12436	expect(i == 2) catch @panic("test failure");
	12437	}
	12438
	12439	extern fn c_ret_vector_2_u64() @Vector(2, u64);
	12440	extern fn c_vector_2_u64(@Vector(2, u64), usize) void;
	12441	extern fn c_test_vector_2_u64() void;
	12442
	12443	test "@Vector(2, u64)" {
	12444	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	12445
	12446	const v = c_ret_vector_2_u64();
	12447	try expect(v[0] == 9);
	12448	try expect(v[1] == 10);
	12449	c_vector_2_u64(.{ 11, 12 }, 2);
	12450	c_test_vector_2_u64();
	12451	}
	12452
	12453	export fn zig_ret_vector_3_u64() @Vector(3, u64) {
	12454	return .{ 13, 14, 15 };
	12455	}
	12456	export fn zig_vector_3_u64(v: @Vector(3, u64), i: usize) void {
	12457	expect(v[0] == 16) catch @panic("test failure");
	12458	expect(v[1] == 17) catch @panic("test failure");
	12459	expect(v[2] == 18) catch @panic("test failure");
	12460	expect(i == 3) catch @panic("test failure");
	12461	}
	12462
	12463	extern fn c_ret_vector_3_u64() @Vector(3, u64);
	12464	extern fn c_vector_3_u64(@Vector(3, u64), usize) void;
	12465	extern fn c_test_vector_3_u64() void;
	12466
	12467	test "@Vector(3, u64)" {
	12468	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	12469	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	12470	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	12471	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	12472	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	12473
	12474	const v = c_ret_vector_3_u64();
	12475	try expect(v[0] == 19);
	12476	try expect(v[1] == 20);
	12477	try expect(v[2] == 21);
	12478	c_vector_3_u64(.{ 22, 23, 24 }, 3);
	12479	c_test_vector_3_u64();
	12480	}
	12481
	12482	export fn zig_ret_vector_4_u64() @Vector(4, u64) {
	12483	return .{ 25, 26, 27, 28 };
	12484	}
	12485	export fn zig_vector_4_u64(v: @Vector(4, u64), i: usize) void {
	12486	expect(v[0] == 29) catch @panic("test failure");
	12487	expect(v[1] == 30) catch @panic("test failure");
	12488	expect(v[2] == 31) catch @panic("test failure");
	12489	expect(v[3] == 32) catch @panic("test failure");
	12490	expect(i == 4) catch @panic("test failure");
	12491	}
	12492
	12493	extern fn c_ret_vector_4_u64() @Vector(4, u64);
	12494	extern fn c_vector_4_u64(@Vector(4, u64), usize) void;
	12495	extern fn c_test_vector_4_u64() void;
	12496
	12497	test "@Vector(4, u64)" {
	12498	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	12499	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	12500	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	12501	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	12502
	12503	const v = c_ret_vector_4_u64();
	12504	try expect(v[0] == 33);
	12505	try expect(v[1] == 34);
	12506	try expect(v[2] == 35);
	12507	try expect(v[3] == 36);
	12508	c_vector_4_u64(.{ 37, 38, 39, 40 }, 4);
	12509	c_test_vector_4_u64();
	12510	}
	12511
	12512	export fn zig_ret_vector_6_u64() @Vector(6, u64) {
	12513	return .{ 41, 42, 43, 44, 45, 46 };
	12514	}
	12515	export fn zig_vector_6_u64(v: @Vector(6, u64), i: usize) void {
	12516	expect(v[0] == 47) catch @panic("test failure");
	12517	expect(v[1] == 48) catch @panic("test failure");
	12518	expect(v[2] == 49) catch @panic("test failure");
	12519	expect(v[3] == 50) catch @panic("test failure");
	12520	expect(v[4] == 51) catch @panic("test failure");
	12521	expect(v[5] == 52) catch @panic("test failure");
	12522	expect(i == 6) catch @panic("test failure");
	12523	}
	12524
	12525	extern fn c_ret_vector_6_u64() @Vector(6, u64);
	12526	extern fn c_vector_6_u64(@Vector(6, u64), usize) void;
	12527	extern fn c_test_vector_6_u64() void;
	12528
	12529	test "@Vector(6, u64)" {
	12530	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	12531	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	12532	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	12533
	12534	const v = c_ret_vector_6_u64();
	12535	try expect(v[0] == 53);
	12536	try expect(v[1] == 54);
	12537	try expect(v[2] == 55);
	12538	try expect(v[3] == 56);
	12539	try expect(v[4] == 57);
	12540	try expect(v[5] == 58);
	12541	c_vector_6_u64(.{ 59, 60, 61, 62, 63, 64 }, 6);
	12542	c_test_vector_6_u64();
	12543	}
	12544
	12545	export fn zig_ret_vector_8_u64() @Vector(8, u64) {
	12546	return .{ 65, 66, 67, 68, 69, 70, 71, 72 };
	12547	}
	12548	export fn zig_vector_8_u64(v: @Vector(8, u64), i: usize) void {
	12549	expect(v[0] == 73) catch @panic("test failure");
	12550	expect(v[1] == 74) catch @panic("test failure");
	12551	expect(v[2] == 75) catch @panic("test failure");
	12552	expect(v[3] == 76) catch @panic("test failure");
	12553	expect(v[4] == 77) catch @panic("test failure");
	12554	expect(v[5] == 78) catch @panic("test failure");
	12555	expect(v[6] == 79) catch @panic("test failure");
	12556	expect(v[7] == 80) catch @panic("test failure");
	12557	expect(i == 8) catch @panic("test failure");
	12558	}
	12559
	12560	extern fn c_ret_vector_8_u64() @Vector(8, u64);
	12561	extern fn c_vector_8_u64(@Vector(8, u64), usize) void;
	12562	extern fn c_test_vector_8_u64() void;
	12563
	12564	test "@Vector(8, u64)" {
	12565	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	12566	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	12567	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	12568	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	12569
	12570	const v = c_ret_vector_8_u64();
	12571	try expect(v[0] == 81);
	12572	try expect(v[1] == 82);
	12573	try expect(v[2] == 83);
	12574	try expect(v[3] == 84);
	12575	try expect(v[4] == 85);
	12576	try expect(v[5] == 86);
	12577	try expect(v[6] == 87);
	12578	try expect(v[7] == 88);
	12579	c_vector_8_u64(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8);
	12580	c_test_vector_8_u64();
	12581	}
	12582
	12583	export fn zig_ret_vector_12_u64() @Vector(12, u64) {
	12584	return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 };
	12585	}
	12586	export fn zig_vector_12_u64(v: @Vector(12, u64), i: usize) void {
	12587	expect(v[0] == 109) catch @panic("test failure");
	12588	expect(v[1] == 110) catch @panic("test failure");
	12589	expect(v[2] == 111) catch @panic("test failure");
	12590	expect(v[3] == 112) catch @panic("test failure");
	12591	expect(v[4] == 113) catch @panic("test failure");
	12592	expect(v[5] == 114) catch @panic("test failure");
	12593	expect(v[6] == 115) catch @panic("test failure");
	12594	expect(v[7] == 116) catch @panic("test failure");
	12595	expect(v[8] == 117) catch @panic("test failure");
	12596	expect(v[9] == 118) catch @panic("test failure");
	12597	expect(v[10] == 119) catch @panic("test failure");
	12598	expect(v[11] == 120) catch @panic("test failure");
	12599	expect(i == 12) catch @panic("test failure");
	12600	}
	12601
	12602	extern fn c_ret_vector_12_u64() @Vector(12, u64);
	12603	extern fn c_vector_12_u64(@Vector(12, u64), usize) void;
	12604	extern fn c_test_vector_12_u64() void;
	12605
	12606	test "@Vector(12, u64)" {
	12607	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	12608	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	12609	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	12610
	12611	const v = c_ret_vector_12_u64();
	12612	try expect(v[0] == 121);
	12613	try expect(v[1] == 122);
	12614	try expect(v[2] == 123);
	12615	try expect(v[3] == 124);
	12616	try expect(v[4] == 125);
	12617	try expect(v[5] == 126);
	12618	try expect(v[6] == 127);
	12619	try expect(v[7] == 128);
	12620	try expect(v[8] == 129);
	12621	try expect(v[9] == 130);
	12622	try expect(v[10] == 131);
	12623	try expect(v[11] == 132);
	12624	c_vector_12_u64(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12);
	12625	c_test_vector_12_u64();
	12626	}
	12627
	12628	export fn zig_ret_vector_16_u64() @Vector(16, u64) {
	12629	return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 };
	12630	}
	12631	export fn zig_vector_16_u64(v: @Vector(16, u64), i: usize) void {
	12632	expect(v[0] == 161) catch @panic("test failure");
	12633	expect(v[1] == 162) catch @panic("test failure");
	12634	expect(v[2] == 163) catch @panic("test failure");
	12635	expect(v[3] == 164) catch @panic("test failure");
	12636	expect(v[4] == 165) catch @panic("test failure");
	12637	expect(v[5] == 166) catch @panic("test failure");
	12638	expect(v[6] == 167) catch @panic("test failure");
	12639	expect(v[7] == 168) catch @panic("test failure");
	12640	expect(v[8] == 169) catch @panic("test failure");
	12641	expect(v[9] == 170) catch @panic("test failure");
	12642	expect(v[10] == 171) catch @panic("test failure");
	12643	expect(v[11] == 172) catch @panic("test failure");
	12644	expect(v[12] == 173) catch @panic("test failure");
	12645	expect(v[13] == 174) catch @panic("test failure");
	12646	expect(v[14] == 175) catch @panic("test failure");
	12647	expect(v[15] == 176) catch @panic("test failure");
	12648	expect(i == 16) catch @panic("test failure");
	12649	}
	12650
	12651	extern fn c_ret_vector_16_u64() @Vector(16, u64);
	12652	extern fn c_vector_16_u64(@Vector(16, u64), usize) void;
	12653	extern fn c_test_vector_16_u64() void;
	12654
	12655	test "@Vector(16, u64)" {
	12656	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	12657	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	12658	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	12659	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	12660	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	12661
	12662	const v = c_ret_vector_16_u64();
	12663	try expect(v[0] == 177);
	12664	try expect(v[1] == 178);
	12665	try expect(v[2] == 179);
	12666	try expect(v[3] == 180);
	12667	try expect(v[4] == 181);
	12668	try expect(v[5] == 182);
	12669	try expect(v[6] == 183);
	12670	try expect(v[7] == 184);
	12671	try expect(v[8] == 185);
	12672	try expect(v[9] == 186);
	12673	try expect(v[10] == 187);
	12674	try expect(v[11] == 188);
	12675	try expect(v[12] == 189);
	12676	try expect(v[13] == 190);
	12677	try expect(v[14] == 191);
	12678	try expect(v[15] == 192);
	12679	c_vector_16_u64(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16);
	12680	c_test_vector_16_u64();
	12681	}
	12682
	12683	export fn zig_ret_vector_24_u64() @Vector(24, u64) {
	12684	return .{
	12685	209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
	12686	225, 226, 227, 228, 229, 230, 231, 232,
	12687	};
	12688	}
	12689	export fn zig_vector_24_u64(v: @Vector(24, u64), i: usize) void {
	12690	expect(v[0] == 233) catch @panic("test failure");
	12691	expect(v[1] == 234) catch @panic("test failure");
	12692	expect(v[2] == 235) catch @panic("test failure");
	12693	expect(v[3] == 236) catch @panic("test failure");
	12694	expect(v[4] == 237) catch @panic("test failure");
	12695	expect(v[5] == 238) catch @panic("test failure");
	12696	expect(v[6] == 239) catch @panic("test failure");
	12697	expect(v[7] == 240) catch @panic("test failure");
	12698	expect(v[8] == 241) catch @panic("test failure");
	12699	expect(v[9] == 242) catch @panic("test failure");
	12700	expect(v[10] == 243) catch @panic("test failure");
	12701	expect(v[11] == 244) catch @panic("test failure");
	12702	expect(v[12] == 245) catch @panic("test failure");
	12703	expect(v[13] == 246) catch @panic("test failure");
	12704	expect(v[14] == 247) catch @panic("test failure");
	12705	expect(v[15] == 248) catch @panic("test failure");
	12706	expect(v[16] == 249) catch @panic("test failure");
	12707	expect(v[17] == 250) catch @panic("test failure");
	12708	expect(v[18] == 251) catch @panic("test failure");
	12709	expect(v[19] == 252) catch @panic("test failure");
	12710	expect(v[20] == 253) catch @panic("test failure");
	12711	expect(v[21] == 254) catch @panic("test failure");
	12712	expect(v[22] == 255) catch @panic("test failure");
	12713	expect(v[23] == 256) catch @panic("test failure");
	12714	expect(i == 24) catch @panic("test failure");
	12715	}
	12716
	12717	extern fn c_ret_vector_24_u64() @Vector(24, u64);
	12718	extern fn c_vector_24_u64(@Vector(24, u64), usize) void;
	12719	extern fn c_test_vector_24_u64() void;
	12720
	12721	test "@Vector(24, u64)" {
	12722	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	12723	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	12724	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	12725
	12726	const v = c_ret_vector_24_u64();
	12727	try expect(v[0] == 257);
	12728	try expect(v[1] == 258);
	12729	try expect(v[2] == 259);
	12730	try expect(v[3] == 260);
	12731	try expect(v[4] == 261);
	12732	try expect(v[5] == 262);
	12733	try expect(v[6] == 263);
	12734	try expect(v[7] == 264);
	12735	try expect(v[8] == 265);
	12736	try expect(v[9] == 266);
	12737	try expect(v[10] == 267);
	12738	try expect(v[11] == 268);
	12739	try expect(v[12] == 269);
	12740	try expect(v[13] == 270);
	12741	try expect(v[14] == 271);
	12742	try expect(v[15] == 272);
	12743	try expect(v[16] == 273);
	12744	try expect(v[17] == 274);
	12745	try expect(v[18] == 275);
	12746	try expect(v[19] == 276);
	12747	try expect(v[20] == 277);
	12748	try expect(v[21] == 278);
	12749	try expect(v[22] == 279);
	12750	try expect(v[23] == 280);
	12751	c_vector_24_u64(.{
	12752	281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
	12753	297, 298, 299, 300, 301, 302, 303, 304,
	12754	}, 24);
	12755	c_test_vector_24_u64();
	12756	}
	12757
	12758	export fn zig_ret_vector_32_u64() @Vector(32, u64) {
	12759	return .{
	12760	305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
	12761	321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
	12762	};
	12763	}
	12764	export fn zig_vector_32_u64(v: @Vector(32, u64), i: usize) void {
	12765	expect(v[0] == 337) catch @panic("test failure");
	12766	expect(v[1] == 338) catch @panic("test failure");
	12767	expect(v[2] == 339) catch @panic("test failure");
	12768	expect(v[3] == 340) catch @panic("test failure");
	12769	expect(v[4] == 341) catch @panic("test failure");
	12770	expect(v[5] == 342) catch @panic("test failure");
	12771	expect(v[6] == 343) catch @panic("test failure");
	12772	expect(v[7] == 344) catch @panic("test failure");
	12773	expect(v[8] == 345) catch @panic("test failure");
	12774	expect(v[9] == 346) catch @panic("test failure");
	12775	expect(v[10] == 347) catch @panic("test failure");
	12776	expect(v[11] == 348) catch @panic("test failure");
	12777	expect(v[12] == 349) catch @panic("test failure");
	12778	expect(v[13] == 350) catch @panic("test failure");
	12779	expect(v[14] == 351) catch @panic("test failure");
	12780	expect(v[15] == 352) catch @panic("test failure");
	12781	expect(v[16] == 353) catch @panic("test failure");
	12782	expect(v[17] == 354) catch @panic("test failure");
	12783	expect(v[18] == 355) catch @panic("test failure");
	12784	expect(v[19] == 356) catch @panic("test failure");
	12785	expect(v[20] == 357) catch @panic("test failure");
	12786	expect(v[21] == 358) catch @panic("test failure");
	12787	expect(v[22] == 359) catch @panic("test failure");
	12788	expect(v[23] == 360) catch @panic("test failure");
	12789	expect(v[24] == 361) catch @panic("test failure");
	12790	expect(v[25] == 362) catch @panic("test failure");
	12791	expect(v[26] == 363) catch @panic("test failure");
	12792	expect(v[27] == 364) catch @panic("test failure");
	12793	expect(v[28] == 365) catch @panic("test failure");
	12794	expect(v[29] == 366) catch @panic("test failure");
	12795	expect(v[30] == 367) catch @panic("test failure");
	12796	expect(v[31] == 368) catch @panic("test failure");
	12797	expect(i == 32) catch @panic("test failure");
	12798	}
	12799
	12800	extern fn c_ret_vector_32_u64() @Vector(32, u64);
	12801	extern fn c_vector_32_u64(@Vector(32, u64), usize) void;
	12802	extern fn c_test_vector_32_u64() void;
	12803
	12804	test "@Vector(32, u64)" {
	12805	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	12806	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	12807	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	12808	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	12809	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	12810
	12811	const v = c_ret_vector_32_u64();
	12812	try expect(v[0] == 369);
	12813	try expect(v[1] == 370);
	12814	try expect(v[2] == 371);
	12815	try expect(v[3] == 372);
	12816	try expect(v[4] == 373);
	12817	try expect(v[5] == 374);
	12818	try expect(v[6] == 375);
	12819	try expect(v[7] == 376);
	12820	try expect(v[8] == 377);
	12821	try expect(v[9] == 378);
	12822	try expect(v[10] == 379);
	12823	try expect(v[11] == 380);
	12824	try expect(v[12] == 381);
	12825	try expect(v[13] == 382);
	12826	try expect(v[14] == 383);
	12827	try expect(v[15] == 384);
	12828	try expect(v[16] == 385);
	12829	try expect(v[17] == 386);
	12830	try expect(v[18] == 387);
	12831	try expect(v[19] == 388);
	12832	try expect(v[20] == 389);
	12833	try expect(v[21] == 390);
	12834	try expect(v[22] == 391);
	12835	try expect(v[23] == 392);
	12836	try expect(v[24] == 393);
	12837	try expect(v[25] == 394);
	12838	try expect(v[26] == 395);
	12839	try expect(v[27] == 396);
	12840	try expect(v[28] == 397);
	12841	try expect(v[29] == 398);
	12842	try expect(v[30] == 399);
	12843	try expect(v[31] == 400);
	12844	c_vector_32_u64(.{
	12845	401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416,
	12846	417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432,
	12847	}, 32);
	12848	c_test_vector_32_u64();
	12849	}
	12850
	12851	export fn zig_ret_vector_48_u64() @Vector(48, u64) {
	12852	return .{
	12853	433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448,
	12854	449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
	12855	465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,
	12856	};
	12857	}
	12858	export fn zig_vector_48_u64(v: @Vector(48, u64), i: usize) void {
	12859	expect(v[0] == 481) catch @panic("test failure");
	12860	expect(v[1] == 482) catch @panic("test failure");
	12861	expect(v[2] == 483) catch @panic("test failure");
	12862	expect(v[3] == 484) catch @panic("test failure");
	12863	expect(v[4] == 485) catch @panic("test failure");
	12864	expect(v[5] == 486) catch @panic("test failure");
	12865	expect(v[6] == 487) catch @panic("test failure");
	12866	expect(v[7] == 488) catch @panic("test failure");
	12867	expect(v[8] == 489) catch @panic("test failure");
	12868	expect(v[9] == 490) catch @panic("test failure");
	12869	expect(v[10] == 491) catch @panic("test failure");
	12870	expect(v[11] == 492) catch @panic("test failure");
	12871	expect(v[12] == 493) catch @panic("test failure");
	12872	expect(v[13] == 494) catch @panic("test failure");
	12873	expect(v[14] == 495) catch @panic("test failure");
	12874	expect(v[15] == 496) catch @panic("test failure");
	12875	expect(v[16] == 497) catch @panic("test failure");
	12876	expect(v[17] == 498) catch @panic("test failure");
	12877	expect(v[18] == 499) catch @panic("test failure");
	12878	expect(v[19] == 500) catch @panic("test failure");
	12879	expect(v[20] == 501) catch @panic("test failure");
	12880	expect(v[21] == 502) catch @panic("test failure");
	12881	expect(v[22] == 503) catch @panic("test failure");
	12882	expect(v[23] == 504) catch @panic("test failure");
	12883	expect(v[24] == 505) catch @panic("test failure");
	12884	expect(v[25] == 506) catch @panic("test failure");
	12885	expect(v[26] == 507) catch @panic("test failure");
	12886	expect(v[27] == 508) catch @panic("test failure");
	12887	expect(v[28] == 509) catch @panic("test failure");
	12888	expect(v[29] == 510) catch @panic("test failure");
	12889	expect(v[30] == 511) catch @panic("test failure");
	12890	expect(v[31] == 512) catch @panic("test failure");
	12891	expect(v[32] == 513) catch @panic("test failure");
	12892	expect(v[33] == 514) catch @panic("test failure");
	12893	expect(v[34] == 515) catch @panic("test failure");
	12894	expect(v[35] == 516) catch @panic("test failure");
	12895	expect(v[36] == 517) catch @panic("test failure");
	12896	expect(v[37] == 518) catch @panic("test failure");
	12897	expect(v[38] == 519) catch @panic("test failure");
	12898	expect(v[39] == 520) catch @panic("test failure");
	12899	expect(v[40] == 521) catch @panic("test failure");
	12900	expect(v[41] == 522) catch @panic("test failure");
	12901	expect(v[42] == 523) catch @panic("test failure");
	12902	expect(v[43] == 524) catch @panic("test failure");
	12903	expect(v[44] == 525) catch @panic("test failure");
	12904	expect(v[45] == 526) catch @panic("test failure");
	12905	expect(v[46] == 527) catch @panic("test failure");
	12906	expect(v[47] == 528) catch @panic("test failure");
	12907	expect(i == 48) catch @panic("test failure");
	12908	}
	12909
	12910	extern fn c_ret_vector_48_u64() @Vector(48, u64);
	12911	extern fn c_vector_48_u64(@Vector(48, u64), usize) void;
	12912	extern fn c_test_vector_48_u64() void;
	12913
	12914	test "@Vector(48, u64)" {
	12915	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	12916	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	12917	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	12918
	12919	const v = c_ret_vector_48_u64();
	12920	try expect(v[0] == 529);
	12921	try expect(v[1] == 530);
	12922	try expect(v[2] == 531);
	12923	try expect(v[3] == 532);
	12924	try expect(v[4] == 533);
	12925	try expect(v[5] == 534);
	12926	try expect(v[6] == 535);
	12927	try expect(v[7] == 536);
	12928	try expect(v[8] == 537);
	12929	try expect(v[9] == 538);
	12930	try expect(v[10] == 539);
	12931	try expect(v[11] == 540);
	12932	try expect(v[12] == 541);
	12933	try expect(v[13] == 542);
	12934	try expect(v[14] == 543);
	12935	try expect(v[15] == 544);
	12936	try expect(v[16] == 545);
	12937	try expect(v[17] == 546);
	12938	try expect(v[18] == 547);
	12939	try expect(v[19] == 548);
	12940	try expect(v[20] == 549);
	12941	try expect(v[21] == 550);
	12942	try expect(v[22] == 551);
	12943	try expect(v[23] == 552);
	12944	try expect(v[24] == 553);
	12945	try expect(v[25] == 554);
	12946	try expect(v[26] == 555);
	12947	try expect(v[27] == 556);
	12948	try expect(v[28] == 557);
	12949	try expect(v[29] == 558);
	12950	try expect(v[30] == 559);
	12951	try expect(v[31] == 560);
	12952	try expect(v[32] == 561);
	12953	try expect(v[33] == 562);
	12954	try expect(v[34] == 563);
	12955	try expect(v[35] == 564);
	12956	try expect(v[36] == 565);
	12957	try expect(v[37] == 566);
	12958	try expect(v[38] == 567);
	12959	try expect(v[39] == 568);
	12960	try expect(v[40] == 569);
	12961	try expect(v[41] == 570);
	12962	try expect(v[42] == 571);
	12963	try expect(v[43] == 572);
	12964	try expect(v[44] == 573);
	12965	try expect(v[45] == 574);
	12966	try expect(v[46] == 575);
	12967	try expect(v[47] == 576);
	12968	c_vector_48_u64(.{
	12969	577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
	12970	593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,
	12971	609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
	12972	}, 48);
	12973	c_test_vector_48_u64();
	12974	}
	12975
	12976	export fn zig_ret_vector_64_u64() @Vector(64, u64) {
	12977	return .{
	12978	625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640,
	12979	641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656,
	12980	657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672,
	12981	673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688,
	12982	};
	12983	}
	12984	export fn zig_vector_64_u64(v: @Vector(64, u64), i: usize) void {
	12985	expect(v[0] == 689) catch @panic("test failure");
	12986	expect(v[1] == 690) catch @panic("test failure");
	12987	expect(v[2] == 691) catch @panic("test failure");
	12988	expect(v[3] == 692) catch @panic("test failure");
	12989	expect(v[4] == 693) catch @panic("test failure");
	12990	expect(v[5] == 694) catch @panic("test failure");
	12991	expect(v[6] == 695) catch @panic("test failure");
	12992	expect(v[7] == 696) catch @panic("test failure");
	12993	expect(v[8] == 697) catch @panic("test failure");
	12994	expect(v[9] == 698) catch @panic("test failure");
	12995	expect(v[10] == 699) catch @panic("test failure");
	12996	expect(v[11] == 700) catch @panic("test failure");
	12997	expect(v[12] == 701) catch @panic("test failure");
	12998	expect(v[13] == 702) catch @panic("test failure");
	12999	expect(v[14] == 703) catch @panic("test failure");
	13000	expect(v[15] == 704) catch @panic("test failure");
	13001	expect(v[16] == 705) catch @panic("test failure");
	13002	expect(v[17] == 706) catch @panic("test failure");
	13003	expect(v[18] == 707) catch @panic("test failure");
	13004	expect(v[19] == 708) catch @panic("test failure");
	13005	expect(v[20] == 709) catch @panic("test failure");
	13006	expect(v[21] == 710) catch @panic("test failure");
	13007	expect(v[22] == 711) catch @panic("test failure");
	13008	expect(v[23] == 712) catch @panic("test failure");
	13009	expect(v[24] == 713) catch @panic("test failure");
	13010	expect(v[25] == 714) catch @panic("test failure");
	13011	expect(v[26] == 715) catch @panic("test failure");
	13012	expect(v[27] == 716) catch @panic("test failure");
	13013	expect(v[28] == 717) catch @panic("test failure");
	13014	expect(v[29] == 718) catch @panic("test failure");
	13015	expect(v[30] == 719) catch @panic("test failure");
	13016	expect(v[31] == 720) catch @panic("test failure");
	13017	expect(v[32] == 721) catch @panic("test failure");
	13018	expect(v[33] == 722) catch @panic("test failure");
	13019	expect(v[34] == 723) catch @panic("test failure");
	13020	expect(v[35] == 724) catch @panic("test failure");
	13021	expect(v[36] == 725) catch @panic("test failure");
	13022	expect(v[37] == 726) catch @panic("test failure");
	13023	expect(v[38] == 727) catch @panic("test failure");
	13024	expect(v[39] == 728) catch @panic("test failure");
	13025	expect(v[40] == 729) catch @panic("test failure");
	13026	expect(v[41] == 730) catch @panic("test failure");
	13027	expect(v[42] == 731) catch @panic("test failure");
	13028	expect(v[43] == 732) catch @panic("test failure");
	13029	expect(v[44] == 733) catch @panic("test failure");
	13030	expect(v[45] == 734) catch @panic("test failure");
	13031	expect(v[46] == 735) catch @panic("test failure");
	13032	expect(v[47] == 736) catch @panic("test failure");
	13033	expect(v[48] == 737) catch @panic("test failure");
	13034	expect(v[49] == 738) catch @panic("test failure");
	13035	expect(v[50] == 739) catch @panic("test failure");
	13036	expect(v[51] == 740) catch @panic("test failure");
	13037	expect(v[52] == 741) catch @panic("test failure");
	13038	expect(v[53] == 742) catch @panic("test failure");
	13039	expect(v[54] == 743) catch @panic("test failure");
	13040	expect(v[55] == 744) catch @panic("test failure");
	13041	expect(v[56] == 745) catch @panic("test failure");
	13042	expect(v[57] == 746) catch @panic("test failure");
	13043	expect(v[58] == 747) catch @panic("test failure");
	13044	expect(v[59] == 748) catch @panic("test failure");
	13045	expect(v[60] == 749) catch @panic("test failure");
	13046	expect(v[61] == 750) catch @panic("test failure");
	13047	expect(v[62] == 751) catch @panic("test failure");
	13048	expect(v[63] == 752) catch @panic("test failure");
	13049	expect(i == 64) catch @panic("test failure");
	13050	}
	13051
	13052	extern fn c_ret_vector_64_u64() @Vector(64, u64);
	13053	extern fn c_vector_64_u64(@Vector(64, u64), usize) void;
	13054	extern fn c_test_vector_64_u64() void;
	13055
	13056	test "@Vector(64, u64)" {
	13057	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	13058	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13059	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	13060	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	13061	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	13062
	13063	const v = c_ret_vector_64_u64();
	13064	try expect(v[0] == 753);
	13065	try expect(v[1] == 754);
	13066	try expect(v[2] == 755);
	13067	try expect(v[3] == 756);
	13068	try expect(v[4] == 757);
	13069	try expect(v[5] == 758);
	13070	try expect(v[6] == 759);
	13071	try expect(v[7] == 760);
	13072	try expect(v[8] == 761);
	13073	try expect(v[9] == 762);
	13074	try expect(v[10] == 763);
	13075	try expect(v[11] == 764);
	13076	try expect(v[12] == 765);
	13077	try expect(v[13] == 766);
	13078	try expect(v[14] == 767);
	13079	try expect(v[15] == 768);
	13080	try expect(v[16] == 769);
	13081	try expect(v[17] == 770);
	13082	try expect(v[18] == 771);
	13083	try expect(v[19] == 772);
	13084	try expect(v[20] == 773);
	13085	try expect(v[21] == 774);
	13086	try expect(v[22] == 775);
	13087	try expect(v[23] == 776);
	13088	try expect(v[24] == 777);
	13089	try expect(v[25] == 778);
	13090	try expect(v[26] == 779);
	13091	try expect(v[27] == 780);
	13092	try expect(v[28] == 781);
	13093	try expect(v[29] == 782);
	13094	try expect(v[30] == 783);
	13095	try expect(v[31] == 784);
	13096	try expect(v[32] == 785);
	13097	try expect(v[33] == 786);
	13098	try expect(v[34] == 787);
	13099	try expect(v[35] == 788);
	13100	try expect(v[36] == 789);
	13101	try expect(v[37] == 790);
	13102	try expect(v[38] == 791);
	13103	try expect(v[39] == 792);
	13104	try expect(v[40] == 793);
	13105	try expect(v[41] == 794);
	13106	try expect(v[42] == 795);
	13107	try expect(v[43] == 796);
	13108	try expect(v[44] == 797);
	13109	try expect(v[45] == 798);
	13110	try expect(v[46] == 799);
	13111	try expect(v[47] == 800);
	13112	try expect(v[48] == 801);
	13113	try expect(v[49] == 802);
	13114	try expect(v[50] == 803);
	13115	try expect(v[51] == 804);
	13116	try expect(v[52] == 805);
	13117	try expect(v[53] == 806);
	13118	try expect(v[54] == 807);
	13119	try expect(v[55] == 808);
	13120	try expect(v[56] == 809);
	13121	try expect(v[57] == 810);
	13122	try expect(v[58] == 811);
	13123	try expect(v[59] == 812);
	13124	try expect(v[60] == 813);
	13125	try expect(v[61] == 814);
	13126	try expect(v[62] == 815);
	13127	try expect(v[63] == 816);
	13128	c_vector_64_u64(.{
	13129	817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832,
	13130	833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848,
	13131	849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864,
	13132	865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880,
	13133	}, 64);
	13134	c_test_vector_64_u64();
	13135	}
	13136
	13137	export fn zig_ret_vector_1_f32() @Vector(1, f32) {
	13138	return .{1};
	13139	}
	13140	export fn zig_vector_1_f32(v: @Vector(1, f32), i: usize) void {
	13141	expect(v[0] == 2) catch @panic("test failure");
	13142	expect(i == 1) catch @panic("test failure");
	13143	}
	13144
	13145	extern fn c_ret_vector_1_f32() @Vector(1, f32);
	13146	extern fn c_vector_1_f32(@Vector(1, f32), usize) void;
	13147	extern fn c_test_vector_1_f32() void;
	13148
	13149	test "@Vector(1, f32)" {
	13150	if (builtin.cpu.arch.isAARCH64()) return error.SkipZigTest;
	13151	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	13152	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13153	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	13154	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	13155	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag != .windows) return error.SkipZigTest;
	13156
	13157	const v = c_ret_vector_1_f32();
	13158	try expect(v[0] == 3);
	13159	c_vector_1_f32(.{4}, 1);
	13160	c_test_vector_1_f32();
	13161	}
	13162
	13163	export fn zig_ret_vector_2_f32() @Vector(2, f32) {
	13164	return .{ 5, 6 };
	13165	}
	13166	export fn zig_vector_2_f32(v: @Vector(2, f32), i: usize) void {
	13167	expect(v[0] == 7) catch @panic("test failure");
	13168	expect(v[1] == 8) catch @panic("test failure");
	13169	expect(i == 2) catch @panic("test failure");
	13170	}
	13171
	13172	extern fn c_ret_vector_2_f32() @Vector(2, f32);
	13173	extern fn c_vector_2_f32(@Vector(2, f32), usize) void;
	13174	extern fn c_test_vector_2_f32() void;
	13175
	13176	test "@Vector(2, f32)" {
	13177	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13178	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	13179	if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64 and builtin.os.tag == .windows) return error.SkipZigTest;
	13180
	13181	const v = c_ret_vector_2_f32();
	13182	try expect(v[0] == 9);
	13183	try expect(v[1] == 10);
	13184	c_vector_2_f32(.{ 11, 12 }, 2);
	13185	c_test_vector_2_f32();
	13186	}
	13187
	13188	export fn zig_ret_vector_3_f32() @Vector(3, f32) {
	13189	return .{ 13, 14, 15 };
	13190	}
	13191	export fn zig_vector_3_f32(v: @Vector(3, f32), i: usize) void {
	13192	expect(v[0] == 16) catch @panic("test failure");
	13193	expect(v[1] == 17) catch @panic("test failure");
	13194	expect(v[2] == 18) catch @panic("test failure");
	13195	expect(i == 3) catch @panic("test failure");
	13196	}
	13197
	13198	extern fn c_ret_vector_3_f32() @Vector(3, f32);
	13199	extern fn c_vector_3_f32(@Vector(3, f32), usize) void;
	13200	extern fn c_test_vector_3_f32() void;
	13201
	13202	test "@Vector(3, f32)" {
	13203	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	13204	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13205	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	13206
	13207	const v = c_ret_vector_3_f32();
	13208	try expect(v[0] == 19);
	13209	try expect(v[1] == 20);
	13210	try expect(v[2] == 21);
	13211	c_vector_3_f32(.{ 22, 23, 24 }, 32);
	13212	c_test_vector_3_f32();
	13213	}
	13214
	13215	export fn zig_ret_vector_4_f32() @Vector(4, f32) {
	13216	return .{ 25, 26, 27, 28 };
	13217	}
	13218	export fn zig_vector_4_f32(v: @Vector(4, f32), i: usize) void {
	13219	expect(v[0] == 29) catch @panic("test failure");
	13220	expect(v[1] == 30) catch @panic("test failure");
	13221	expect(v[2] == 31) catch @panic("test failure");
	13222	expect(v[3] == 32) catch @panic("test failure");
	13223	expect(i == 4) catch @panic("test failure");
	13224	}
	13225	export fn zig_vector_4_f32_vector_4_f32(v0: @Vector(4, f32), v1: @Vector(4, f32), i: usize) void {
	13226	expect(v0[0] == 33) catch @panic("test failure");
	13227	expect(v0[1] == 34) catch @panic("test failure");
	13228	expect(v0[2] == 35) catch @panic("test failure");
	13229	expect(v0[3] == 36) catch @panic("test failure");
	13230	expect(v1[0] == 37) catch @panic("test failure");
	13231	expect(v1[1] == 38) catch @panic("test failure");
	13232	expect(v1[2] == 39) catch @panic("test failure");
	13233	expect(v1[3] == 40) catch @panic("test failure");
	13234	expect(i == 8) catch @panic("test failure");
	13235	}
	13236	extern fn c_ret_vector_4_f32() @Vector(4, f32);
	13237
	13238	extern fn c_vector_4_f32(@Vector(4, f32), usize) void;
	13239	extern fn c_vector_4_f32_vector_4_f32(@Vector(4, f32), @Vector(4, f32), usize) void;
	13240	extern fn c_test_vector_4_f32() void;
	13241
	13242	test "@Vector(4, f32)" {
	13243	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13244
	13245	const v = c_ret_vector_4_f32();
	13246	try expect(v[0] == 41);
	13247	try expect(v[1] == 42);
	13248	try expect(v[2] == 43);
	13249	try expect(v[3] == 44);
	13250	c_vector_4_f32(.{ 45, 46, 47, 48 }, 4);
	13251	c_vector_4_f32_vector_4_f32(.{ 49, 50, 51, 52 }, .{ 53, 54, 55, 56 }, 8);
	13252	c_test_vector_4_f32();
	13253	}
	13254
	13255	export fn zig_ret_vector_6_f32() @Vector(6, f32) {
	13256	return .{ 41, 42, 43, 44, 45, 46 };
	13257	}
	13258	export fn zig_vector_6_f32(v: @Vector(6, f32), i: usize) void {
	13259	expect(v[0] == 47) catch @panic("test failure");
	13260	expect(v[1] == 48) catch @panic("test failure");
	13261	expect(v[2] == 49) catch @panic("test failure");
	13262	expect(v[3] == 50) catch @panic("test failure");
	13263	expect(v[4] == 51) catch @panic("test failure");
	13264	expect(v[5] == 52) catch @panic("test failure");
	13265	expect(i == 6) catch @panic("test failure");
	13266	}
	13267
	13268	extern fn c_ret_vector_6_f32() @Vector(6, f32);
	13269	extern fn c_vector_6_f32(@Vector(6, f32), usize) void;
	13270	extern fn c_test_vector_6_f32() void;
	13271
	13272	test "@Vector(6, f32)" {
	13273	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	13274	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13275	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	13276	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	13277	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	13278
	13279	const v = c_ret_vector_6_f32();
	13280	try expect(v[0] == 53);
	13281	try expect(v[1] == 54);
	13282	try expect(v[2] == 55);
	13283	try expect(v[3] == 56);
	13284	try expect(v[4] == 57);
	13285	try expect(v[5] == 58);
	13286	c_vector_6_f32(.{ 59, 60, 61, 62, 63, 64 }, 6);
	13287	c_test_vector_6_f32();
	13288	}
	13289
	13290	export fn zig_ret_vector_8_f32() @Vector(8, f32) {
	13291	return .{ 65, 66, 67, 68, 69, 70, 71, 72 };
	13292	}
	13293	export fn zig_vector_8_f32(v: @Vector(8, f32), i: usize) void {
	13294	expect(v[0] == 73) catch @panic("test failure");
	13295	expect(v[1] == 74) catch @panic("test failure");
	13296	expect(v[2] == 75) catch @panic("test failure");
	13297	expect(v[3] == 76) catch @panic("test failure");
	13298	expect(v[4] == 77) catch @panic("test failure");
	13299	expect(v[5] == 78) catch @panic("test failure");
	13300	expect(v[6] == 79) catch @panic("test failure");
	13301	expect(v[7] == 80) catch @panic("test failure");
	13302	expect(i == 8) catch @panic("test failure");
	13303	}
	13304
	13305	extern fn c_ret_vector_8_f32() @Vector(8, f32);
	13306	extern fn c_vector_8_f32(@Vector(8, f32), usize) void;
	13307	extern fn c_test_vector_8_f32() void;
	13308
	13309	test "@Vector(8, f32)" {
	13310	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	13311	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13312	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	13313	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	13314	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	13315
	13316	const v = c_ret_vector_8_f32();
	13317	try expect(v[0] == 81);
	13318	try expect(v[1] == 82);
	13319	try expect(v[2] == 83);
	13320	try expect(v[3] == 84);
	13321	try expect(v[4] == 85);
	13322	try expect(v[5] == 86);
	13323	try expect(v[6] == 87);
	13324	try expect(v[7] == 88);
	13325	c_vector_8_f32(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8);
	13326	c_test_vector_8_f32();
	13327	}
	13328
	13329	export fn zig_ret_vector_12_f32() @Vector(12, f32) {
	13330	return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 };
	13331	}
	13332	export fn zig_vector_12_f32(v: @Vector(12, f32), i: usize) void {
	13333	expect(v[0] == 109) catch @panic("test failure");
	13334	expect(v[1] == 110) catch @panic("test failure");
	13335	expect(v[2] == 111) catch @panic("test failure");
	13336	expect(v[3] == 112) catch @panic("test failure");
	13337	expect(v[4] == 113) catch @panic("test failure");
	13338	expect(v[5] == 114) catch @panic("test failure");
	13339	expect(v[6] == 115) catch @panic("test failure");
	13340	expect(v[7] == 116) catch @panic("test failure");
	13341	expect(v[8] == 117) catch @panic("test failure");
	13342	expect(v[9] == 118) catch @panic("test failure");
	13343	expect(v[10] == 119) catch @panic("test failure");
	13344	expect(v[11] == 120) catch @panic("test failure");
	13345	expect(i == 12) catch @panic("test failure");
	13346	}
	13347
	13348	extern fn c_ret_vector_12_f32() @Vector(12, f32);
	13349	extern fn c_vector_12_f32(@Vector(12, f32), usize) void;
	13350	extern fn c_test_vector_12_f32() void;
	13351
	13352	test "@Vector(12, f32)" {
	13353	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	13354	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13355	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	13356	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	13357	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	13358
	13359	const v = c_ret_vector_12_f32();
	13360	try expect(v[0] == 121);
	13361	try expect(v[1] == 122);
	13362	try expect(v[2] == 123);
	13363	try expect(v[3] == 124);
	13364	try expect(v[4] == 125);
	13365	try expect(v[5] == 126);
	13366	try expect(v[6] == 127);
	13367	try expect(v[7] == 128);
	13368	try expect(v[8] == 129);
	13369	try expect(v[9] == 130);
	13370	try expect(v[10] == 131);
	13371	try expect(v[11] == 132);
	13372	c_vector_12_f32(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12);
	13373	c_test_vector_12_f32();
	13374	}
	13375
	13376	export fn zig_ret_vector_16_f32() @Vector(16, f32) {
	13377	return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 };
	13378	}
	13379	export fn zig_vector_16_f32(v: @Vector(16, f32), i: usize) void {
	13380	expect(v[0] == 161) catch @panic("test failure");
	13381	expect(v[1] == 162) catch @panic("test failure");
	13382	expect(v[2] == 163) catch @panic("test failure");
	13383	expect(v[3] == 164) catch @panic("test failure");
	13384	expect(v[4] == 165) catch @panic("test failure");
	13385	expect(v[5] == 166) catch @panic("test failure");
	13386	expect(v[6] == 167) catch @panic("test failure");
	13387	expect(v[7] == 168) catch @panic("test failure");
	13388	expect(v[8] == 169) catch @panic("test failure");
	13389	expect(v[9] == 170) catch @panic("test failure");
	13390	expect(v[10] == 171) catch @panic("test failure");
	13391	expect(v[11] == 172) catch @panic("test failure");
	13392	expect(v[12] == 173) catch @panic("test failure");
	13393	expect(v[13] == 174) catch @panic("test failure");
	13394	expect(v[14] == 175) catch @panic("test failure");
	13395	expect(v[15] == 176) catch @panic("test failure");
	13396	expect(i == 16) catch @panic("test failure");
	13397	}
	13398
	13399	extern fn c_ret_vector_16_f32() @Vector(16, f32);
	13400	extern fn c_vector_16_f32(@Vector(16, f32), usize) void;
	13401	extern fn c_test_vector_16_f32() void;
	13402
	13403	test "@Vector(16, f32)" {
	13404	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	13405	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13406	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	13407	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	13408	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	13409
	13410	const v = c_ret_vector_16_f32();
	13411	try expect(v[0] == 177);
	13412	try expect(v[1] == 178);
	13413	try expect(v[2] == 179);
	13414	try expect(v[3] == 180);
	13415	try expect(v[4] == 181);
	13416	try expect(v[5] == 182);
	13417	try expect(v[6] == 183);
	13418	try expect(v[7] == 184);
	13419	try expect(v[8] == 185);
	13420	try expect(v[9] == 186);
	13421	try expect(v[10] == 187);
	13422	try expect(v[11] == 188);
	13423	try expect(v[12] == 189);
	13424	try expect(v[13] == 190);
	13425	try expect(v[14] == 191);
	13426	try expect(v[15] == 192);
	13427	c_vector_16_f32(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16);
	13428	c_test_vector_16_f32();
	13429	}
	13430
	13431	export fn zig_ret_vector_24_f32() @Vector(24, f32) {
	13432	return .{
	13433	209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
	13434	225, 226, 227, 228, 229, 230, 231, 232,
	13435	};
	13436	}
	13437	export fn zig_vector_24_f32(v: @Vector(24, f32), i: usize) void {
	13438	expect(v[0] == 233) catch @panic("test failure");
	13439	expect(v[1] == 234) catch @panic("test failure");
	13440	expect(v[2] == 235) catch @panic("test failure");
	13441	expect(v[3] == 236) catch @panic("test failure");
	13442	expect(v[4] == 237) catch @panic("test failure");
	13443	expect(v[5] == 238) catch @panic("test failure");
	13444	expect(v[6] == 239) catch @panic("test failure");
	13445	expect(v[7] == 240) catch @panic("test failure");
	13446	expect(v[8] == 241) catch @panic("test failure");
	13447	expect(v[9] == 242) catch @panic("test failure");
	13448	expect(v[10] == 243) catch @panic("test failure");
	13449	expect(v[11] == 244) catch @panic("test failure");
	13450	expect(v[12] == 245) catch @panic("test failure");
	13451	expect(v[13] == 246) catch @panic("test failure");
	13452	expect(v[14] == 247) catch @panic("test failure");
	13453	expect(v[15] == 248) catch @panic("test failure");
	13454	expect(v[16] == 249) catch @panic("test failure");
	13455	expect(v[17] == 250) catch @panic("test failure");
	13456	expect(v[18] == 251) catch @panic("test failure");
	13457	expect(v[19] == 252) catch @panic("test failure");
	13458	expect(v[20] == 253) catch @panic("test failure");
	13459	expect(v[21] == 254) catch @panic("test failure");
	13460	expect(v[22] == 255) catch @panic("test failure");
	13461	expect(v[23] == 256) catch @panic("test failure");
	13462	expect(i == 24) catch @panic("test failure");
	13463	}
	13464
	13465	extern fn c_ret_vector_24_f32() @Vector(24, f32);
	13466	extern fn c_vector_24_f32(@Vector(24, f32), usize) void;
	13467	extern fn c_test_vector_24_f32() void;
	13468
	13469	test "@Vector(24, f32)" {
	13470	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	13471	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13472	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	13473	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	13474	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	13475
	13476	const v = c_ret_vector_24_f32();
	13477	try expect(v[0] == 257);
	13478	try expect(v[1] == 258);
	13479	try expect(v[2] == 259);
	13480	try expect(v[3] == 260);
	13481	try expect(v[4] == 261);
	13482	try expect(v[5] == 262);
	13483	try expect(v[6] == 263);
	13484	try expect(v[7] == 264);
	13485	try expect(v[8] == 265);
	13486	try expect(v[9] == 266);
	13487	try expect(v[10] == 267);
	13488	try expect(v[11] == 268);
	13489	try expect(v[12] == 269);
	13490	try expect(v[13] == 270);
	13491	try expect(v[14] == 271);
	13492	try expect(v[15] == 272);
	13493	try expect(v[16] == 273);
	13494	try expect(v[17] == 274);
	13495	try expect(v[18] == 275);
	13496	try expect(v[19] == 276);
	13497	try expect(v[20] == 277);
	13498	try expect(v[21] == 278);
	13499	try expect(v[22] == 279);
	13500	try expect(v[23] == 280);
	13501	c_vector_24_f32(.{
	13502	281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
	13503	297, 298, 299, 300, 301, 302, 303, 304,
	13504	}, 24);
	13505	c_test_vector_24_f32();
	13506	}
	13507
	13508	export fn zig_ret_vector_32_f32() @Vector(32, f32) {
	13509	return .{
	13510	305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
	13511	321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
	13512	};
	13513	}
	13514	export fn zig_vector_32_f32(v: @Vector(32, f32), i: usize) void {
	13515	expect(v[0] == 337) catch @panic("test failure");
	13516	expect(v[1] == 338) catch @panic("test failure");
	13517	expect(v[2] == 339) catch @panic("test failure");
	13518	expect(v[3] == 340) catch @panic("test failure");
	13519	expect(v[4] == 341) catch @panic("test failure");
	13520	expect(v[5] == 342) catch @panic("test failure");
	13521	expect(v[6] == 343) catch @panic("test failure");
	13522	expect(v[7] == 344) catch @panic("test failure");
	13523	expect(v[8] == 345) catch @panic("test failure");
	13524	expect(v[9] == 346) catch @panic("test failure");
	13525	expect(v[10] == 347) catch @panic("test failure");
	13526	expect(v[11] == 348) catch @panic("test failure");
	13527	expect(v[12] == 349) catch @panic("test failure");
	13528	expect(v[13] == 350) catch @panic("test failure");
	13529	expect(v[14] == 351) catch @panic("test failure");
	13530	expect(v[15] == 352) catch @panic("test failure");
	13531	expect(v[16] == 353) catch @panic("test failure");
	13532	expect(v[17] == 354) catch @panic("test failure");
	13533	expect(v[18] == 355) catch @panic("test failure");
	13534	expect(v[19] == 356) catch @panic("test failure");
	13535	expect(v[20] == 357) catch @panic("test failure");
	13536	expect(v[21] == 358) catch @panic("test failure");
	13537	expect(v[22] == 359) catch @panic("test failure");
	13538	expect(v[23] == 360) catch @panic("test failure");
	13539	expect(v[24] == 361) catch @panic("test failure");
	13540	expect(v[25] == 362) catch @panic("test failure");
	13541	expect(v[26] == 363) catch @panic("test failure");
	13542	expect(v[27] == 364) catch @panic("test failure");
	13543	expect(v[28] == 365) catch @panic("test failure");
	13544	expect(v[29] == 366) catch @panic("test failure");
	13545	expect(v[30] == 367) catch @panic("test failure");
	13546	expect(v[31] == 368) catch @panic("test failure");
	13547	expect(i == 32) catch @panic("test failure");
	13548	}
	13549
	13550	extern fn c_ret_vector_32_f32() @Vector(32, f32);
	13551	extern fn c_vector_32_f32(@Vector(32, f32), usize) void;
	13552	extern fn c_test_vector_32_f32() void;
	13553
	13554	test "@Vector(32, f32)" {
	13555	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	13556	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13557	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	13558	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	13559	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	13560
	13561	const v = c_ret_vector_32_f32();
	13562	try expect(v[0] == 369);
	13563	try expect(v[1] == 370);
	13564	try expect(v[2] == 371);
	13565	try expect(v[3] == 372);
	13566	try expect(v[4] == 373);
	13567	try expect(v[5] == 374);
	13568	try expect(v[6] == 375);
	13569	try expect(v[7] == 376);
	13570	try expect(v[8] == 377);
	13571	try expect(v[9] == 378);
	13572	try expect(v[10] == 379);
	13573	try expect(v[11] == 380);
	13574	try expect(v[12] == 381);
	13575	try expect(v[13] == 382);
	13576	try expect(v[14] == 383);
	13577	try expect(v[15] == 384);
	13578	try expect(v[16] == 385);
	13579	try expect(v[17] == 386);
	13580	try expect(v[18] == 387);
	13581	try expect(v[19] == 388);
	13582	try expect(v[20] == 389);
	13583	try expect(v[21] == 390);
	13584	try expect(v[22] == 391);
	13585	try expect(v[23] == 392);
	13586	try expect(v[24] == 393);
	13587	try expect(v[25] == 394);
	13588	try expect(v[26] == 395);
	13589	try expect(v[27] == 396);
	13590	try expect(v[28] == 397);
	13591	try expect(v[29] == 398);
	13592	try expect(v[30] == 399);
	13593	try expect(v[31] == 400);
	13594	c_vector_32_f32(.{
	13595	401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416,
	13596	417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432,
	13597	}, 32);
	13598	c_test_vector_32_f32();
	13599	}
	13600
	13601	export fn zig_ret_vector_48_f32() @Vector(48, f32) {
	13602	return .{
	13603	433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448,
	13604	449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
	13605	465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,
	13606	};
	13607	}
	13608	export fn zig_vector_48_f32(v: @Vector(48, f32), i: usize) void {
	13609	expect(v[0] == 481) catch @panic("test failure");
	13610	expect(v[1] == 482) catch @panic("test failure");
	13611	expect(v[2] == 483) catch @panic("test failure");
	13612	expect(v[3] == 484) catch @panic("test failure");
	13613	expect(v[4] == 485) catch @panic("test failure");
	13614	expect(v[5] == 486) catch @panic("test failure");
	13615	expect(v[6] == 487) catch @panic("test failure");
	13616	expect(v[7] == 488) catch @panic("test failure");
	13617	expect(v[8] == 489) catch @panic("test failure");
	13618	expect(v[9] == 490) catch @panic("test failure");
	13619	expect(v[10] == 491) catch @panic("test failure");
	13620	expect(v[11] == 492) catch @panic("test failure");
	13621	expect(v[12] == 493) catch @panic("test failure");
	13622	expect(v[13] == 494) catch @panic("test failure");
	13623	expect(v[14] == 495) catch @panic("test failure");
	13624	expect(v[15] == 496) catch @panic("test failure");
	13625	expect(v[16] == 497) catch @panic("test failure");
	13626	expect(v[17] == 498) catch @panic("test failure");
	13627	expect(v[18] == 499) catch @panic("test failure");
	13628	expect(v[19] == 500) catch @panic("test failure");
	13629	expect(v[20] == 501) catch @panic("test failure");
	13630	expect(v[21] == 502) catch @panic("test failure");
	13631	expect(v[22] == 503) catch @panic("test failure");
	13632	expect(v[23] == 504) catch @panic("test failure");
	13633	expect(v[24] == 505) catch @panic("test failure");
	13634	expect(v[25] == 506) catch @panic("test failure");
	13635	expect(v[26] == 507) catch @panic("test failure");
	13636	expect(v[27] == 508) catch @panic("test failure");
	13637	expect(v[28] == 509) catch @panic("test failure");
	13638	expect(v[29] == 510) catch @panic("test failure");
	13639	expect(v[30] == 511) catch @panic("test failure");
	13640	expect(v[31] == 512) catch @panic("test failure");
	13641	expect(v[32] == 513) catch @panic("test failure");
	13642	expect(v[33] == 514) catch @panic("test failure");
	13643	expect(v[34] == 515) catch @panic("test failure");
	13644	expect(v[35] == 516) catch @panic("test failure");
	13645	expect(v[36] == 517) catch @panic("test failure");
	13646	expect(v[37] == 518) catch @panic("test failure");
	13647	expect(v[38] == 519) catch @panic("test failure");
	13648	expect(v[39] == 520) catch @panic("test failure");
	13649	expect(v[40] == 521) catch @panic("test failure");
	13650	expect(v[41] == 522) catch @panic("test failure");
	13651	expect(v[42] == 523) catch @panic("test failure");
	13652	expect(v[43] == 524) catch @panic("test failure");
	13653	expect(v[44] == 525) catch @panic("test failure");
	13654	expect(v[45] == 526) catch @panic("test failure");
	13655	expect(v[46] == 527) catch @panic("test failure");
	13656	expect(v[47] == 528) catch @panic("test failure");
	13657	expect(i == 48) catch @panic("test failure");
	13658	}
	13659
	13660	extern fn c_ret_vector_48_f32() @Vector(48, f32);
	13661	extern fn c_vector_48_f32(@Vector(48, f32), usize) void;
	13662	extern fn c_test_vector_48_f32() void;
	13663
	13664	test "@Vector(48, f32)" {
	13665	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	13666	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13667	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	13668	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	13669	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	13670
	13671	const v = c_ret_vector_48_f32();
	13672	try expect(v[0] == 529);
	13673	try expect(v[1] == 530);
	13674	try expect(v[2] == 531);
	13675	try expect(v[3] == 532);
	13676	try expect(v[4] == 533);
	13677	try expect(v[5] == 534);
	13678	try expect(v[6] == 535);
	13679	try expect(v[7] == 536);
	13680	try expect(v[8] == 537);
	13681	try expect(v[9] == 538);
	13682	try expect(v[10] == 539);
	13683	try expect(v[11] == 540);
	13684	try expect(v[12] == 541);
	13685	try expect(v[13] == 542);
	13686	try expect(v[14] == 543);
	13687	try expect(v[15] == 544);
	13688	try expect(v[16] == 545);
	13689	try expect(v[17] == 546);
	13690	try expect(v[18] == 547);
	13691	try expect(v[19] == 548);
	13692	try expect(v[20] == 549);
	13693	try expect(v[21] == 550);
	13694	try expect(v[22] == 551);
	13695	try expect(v[23] == 552);
	13696	try expect(v[24] == 553);
	13697	try expect(v[25] == 554);
	13698	try expect(v[26] == 555);
	13699	try expect(v[27] == 556);
	13700	try expect(v[28] == 557);
	13701	try expect(v[29] == 558);
	13702	try expect(v[30] == 559);
	13703	try expect(v[31] == 560);
	13704	try expect(v[32] == 561);
	13705	try expect(v[33] == 562);
	13706	try expect(v[34] == 563);
	13707	try expect(v[35] == 564);
	13708	try expect(v[36] == 565);
	13709	try expect(v[37] == 566);
	13710	try expect(v[38] == 567);
	13711	try expect(v[39] == 568);
	13712	try expect(v[40] == 569);
	13713	try expect(v[41] == 570);
	13714	try expect(v[42] == 571);
	13715	try expect(v[43] == 572);
	13716	try expect(v[44] == 573);
	13717	try expect(v[45] == 574);
	13718	try expect(v[46] == 575);
	13719	try expect(v[47] == 576);
	13720	c_vector_48_f32(.{
	13721	577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
	13722	593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,
	13723	609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
	13724	}, 48);
	13725	c_test_vector_48_f32();
	13726	}
	13727
	13728	export fn zig_ret_vector_64_f32() @Vector(64, f32) {
	13729	return .{
	13730	625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640,
	13731	641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656,
	13732	657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672,
	13733	673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688,
	13734	};
	13735	}
	13736	export fn zig_vector_64_f32(v: @Vector(64, f32), i: usize) void {
	13737	expect(v[0] == 689) catch @panic("test failure");
	13738	expect(v[1] == 690) catch @panic("test failure");
	13739	expect(v[2] == 691) catch @panic("test failure");
	13740	expect(v[3] == 692) catch @panic("test failure");
	13741	expect(v[4] == 693) catch @panic("test failure");
	13742	expect(v[5] == 694) catch @panic("test failure");
	13743	expect(v[6] == 695) catch @panic("test failure");
	13744	expect(v[7] == 696) catch @panic("test failure");
	13745	expect(v[8] == 697) catch @panic("test failure");
	13746	expect(v[9] == 698) catch @panic("test failure");
	13747	expect(v[10] == 699) catch @panic("test failure");
	13748	expect(v[11] == 700) catch @panic("test failure");
	13749	expect(v[12] == 701) catch @panic("test failure");
	13750	expect(v[13] == 702) catch @panic("test failure");
	13751	expect(v[14] == 703) catch @panic("test failure");
	13752	expect(v[15] == 704) catch @panic("test failure");
	13753	expect(v[16] == 705) catch @panic("test failure");
	13754	expect(v[17] == 706) catch @panic("test failure");
	13755	expect(v[18] == 707) catch @panic("test failure");
	13756	expect(v[19] == 708) catch @panic("test failure");
	13757	expect(v[20] == 709) catch @panic("test failure");
	13758	expect(v[21] == 710) catch @panic("test failure");
	13759	expect(v[22] == 711) catch @panic("test failure");
	13760	expect(v[23] == 712) catch @panic("test failure");
	13761	expect(v[24] == 713) catch @panic("test failure");
	13762	expect(v[25] == 714) catch @panic("test failure");
	13763	expect(v[26] == 715) catch @panic("test failure");
	13764	expect(v[27] == 716) catch @panic("test failure");
	13765	expect(v[28] == 717) catch @panic("test failure");
	13766	expect(v[29] == 718) catch @panic("test failure");
	13767	expect(v[30] == 719) catch @panic("test failure");
	13768	expect(v[31] == 720) catch @panic("test failure");
	13769	expect(v[32] == 721) catch @panic("test failure");
	13770	expect(v[33] == 722) catch @panic("test failure");
	13771	expect(v[34] == 723) catch @panic("test failure");
	13772	expect(v[35] == 724) catch @panic("test failure");
	13773	expect(v[36] == 725) catch @panic("test failure");
	13774	expect(v[37] == 726) catch @panic("test failure");
	13775	expect(v[38] == 727) catch @panic("test failure");
	13776	expect(v[39] == 728) catch @panic("test failure");
	13777	expect(v[40] == 729) catch @panic("test failure");
	13778	expect(v[41] == 730) catch @panic("test failure");
	13779	expect(v[42] == 731) catch @panic("test failure");
	13780	expect(v[43] == 732) catch @panic("test failure");
	13781	expect(v[44] == 733) catch @panic("test failure");
	13782	expect(v[45] == 734) catch @panic("test failure");
	13783	expect(v[46] == 735) catch @panic("test failure");
	13784	expect(v[47] == 736) catch @panic("test failure");
	13785	expect(v[48] == 737) catch @panic("test failure");
	13786	expect(v[49] == 738) catch @panic("test failure");
	13787	expect(v[50] == 739) catch @panic("test failure");
	13788	expect(v[51] == 740) catch @panic("test failure");
	13789	expect(v[52] == 741) catch @panic("test failure");
	13790	expect(v[53] == 742) catch @panic("test failure");
	13791	expect(v[54] == 743) catch @panic("test failure");
	13792	expect(v[55] == 744) catch @panic("test failure");
	13793	expect(v[56] == 745) catch @panic("test failure");
	13794	expect(v[57] == 746) catch @panic("test failure");
	13795	expect(v[58] == 747) catch @panic("test failure");
	13796	expect(v[59] == 748) catch @panic("test failure");
	13797	expect(v[60] == 749) catch @panic("test failure");
	13798	expect(v[61] == 750) catch @panic("test failure");
	13799	expect(v[62] == 751) catch @panic("test failure");
	13800	expect(v[63] == 752) catch @panic("test failure");
	13801	expect(i == 64) catch @panic("test failure");
	13802	}
	13803
	13804	extern fn c_ret_vector_64_f32() @Vector(64, f32);
	13805	extern fn c_vector_64_f32(@Vector(64, f32), usize) void;
	13806	extern fn c_test_vector_64_f32() void;
	13807
	13808	test "@Vector(64, f32)" {
	13809	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	13810	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	13811	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	13812	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	13813	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	13814
	13815	const v = c_ret_vector_64_f32();
	13816	try expect(v[0] == 753);
	13817	try expect(v[1] == 754);
	13818	try expect(v[2] == 755);
	13819	try expect(v[3] == 756);
	13820	try expect(v[4] == 757);
	13821	try expect(v[5] == 758);
	13822	try expect(v[6] == 759);
	13823	try expect(v[7] == 760);
	13824	try expect(v[8] == 761);
	13825	try expect(v[9] == 762);
	13826	try expect(v[10] == 763);
	13827	try expect(v[11] == 764);
	13828	try expect(v[12] == 765);
	13829	try expect(v[13] == 766);
	13830	try expect(v[14] == 767);
	13831	try expect(v[15] == 768);
	13832	try expect(v[16] == 769);
	13833	try expect(v[17] == 770);
	13834	try expect(v[18] == 771);
	13835	try expect(v[19] == 772);
	13836	try expect(v[20] == 773);
	13837	try expect(v[21] == 774);
	13838	try expect(v[22] == 775);
	13839	try expect(v[23] == 776);
	13840	try expect(v[24] == 777);
	13841	try expect(v[25] == 778);
	13842	try expect(v[26] == 779);
	13843	try expect(v[27] == 780);
	13844	try expect(v[28] == 781);
	13845	try expect(v[29] == 782);
	13846	try expect(v[30] == 783);
	13847	try expect(v[31] == 784);
	13848	try expect(v[32] == 785);
	13849	try expect(v[33] == 786);
	13850	try expect(v[34] == 787);
	13851	try expect(v[35] == 788);
	13852	try expect(v[36] == 789);
	13853	try expect(v[37] == 790);
	13854	try expect(v[38] == 791);
	13855	try expect(v[39] == 792);
	13856	try expect(v[40] == 793);
	13857	try expect(v[41] == 794);
	13858	try expect(v[42] == 795);
	13859	try expect(v[43] == 796);
	13860	try expect(v[44] == 797);
	13861	try expect(v[45] == 798);
	13862	try expect(v[46] == 799);
	13863	try expect(v[47] == 800);
	13864	try expect(v[48] == 801);
	13865	try expect(v[49] == 802);
	13866	try expect(v[50] == 803);
	13867	try expect(v[51] == 804);
	13868	try expect(v[52] == 805);
	13869	try expect(v[53] == 806);
	13870	try expect(v[54] == 807);
	13871	try expect(v[55] == 808);
	13872	try expect(v[56] == 809);
	13873	try expect(v[57] == 810);
	13874	try expect(v[58] == 811);
	13875	try expect(v[59] == 812);
	13876	try expect(v[60] == 813);
	13877	try expect(v[61] == 814);
	13878	try expect(v[62] == 815);
	13879	try expect(v[63] == 816);
	13880	c_vector_64_f32(.{
	13881	817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832,
	13882	833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848,
	13883	849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864,
	13884	865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880,
	13885	}, 64);
	13886	c_test_vector_64_f32();
	13887	}
	13888
	13889	export fn zig_ret_vector_96_f32() @Vector(96, f32) {
	13890	return .{
	13891	890, 891, 892, 893, 894, 895, 896, 897, 898, 899, 900, 901, 902, 903, 904, 905,
	13892	906, 907, 908, 909, 910, 911, 912, 913, 914, 915, 916, 917, 918, 919, 920, 921,
	13893	922, 923, 924, 925, 926, 927, 928, 929, 930, 931, 932, 933, 934, 935, 936, 937,
	13894	938, 939, 940, 941, 942, 943, 944, 945, 946, 947, 948, 949, 950, 951, 952, 953,
	13895	954, 955, 956, 957, 958, 959, 960, 961, 962, 963, 964, 965, 966, 967, 968, 969,
	13896	970, 971, 972, 973, 974, 975, 976, 977, 978, 979, 980, 981, 982, 983, 984, 985,
	13897	};
	13898	}
	13899	export fn zig_vector_96_f32(v: @Vector(96, f32), i: usize) void {
	13900	expect(v[0] == 986) catch @panic("test failure");
	13901	expect(v[1] == 987) catch @panic("test failure");
	13902	expect(v[2] == 988) catch @panic("test failure");
	13903	expect(v[3] == 989) catch @panic("test failure");
	13904	expect(v[4] == 990) catch @panic("test failure");
	13905	expect(v[5] == 991) catch @panic("test failure");
	13906	expect(v[6] == 992) catch @panic("test failure");
	13907	expect(v[7] == 993) catch @panic("test failure");
	13908	expect(v[8] == 994) catch @panic("test failure");
	13909	expect(v[9] == 995) catch @panic("test failure");
	13910	expect(v[10] == 996) catch @panic("test failure");
	13911	expect(v[11] == 997) catch @panic("test failure");
	13912	expect(v[12] == 998) catch @panic("test failure");
	13913	expect(v[13] == 999) catch @panic("test failure");
	13914	expect(v[14] == 1000) catch @panic("test failure");
	13915	expect(v[15] == 1001) catch @panic("test failure");
	13916	expect(v[16] == 1002) catch @panic("test failure");
	13917	expect(v[17] == 1003) catch @panic("test failure");
	13918	expect(v[18] == 1004) catch @panic("test failure");
	13919	expect(v[19] == 1005) catch @panic("test failure");
	13920	expect(v[20] == 1006) catch @panic("test failure");
	13921	expect(v[21] == 1007) catch @panic("test failure");
	13922	expect(v[22] == 1008) catch @panic("test failure");
	13923	expect(v[23] == 1009) catch @panic("test failure");
	13924	expect(v[24] == 1010) catch @panic("test failure");
	13925	expect(v[25] == 1011) catch @panic("test failure");
	13926	expect(v[26] == 1012) catch @panic("test failure");
	13927	expect(v[27] == 1013) catch @panic("test failure");
	13928	expect(v[28] == 1014) catch @panic("test failure");
	13929	expect(v[29] == 1015) catch @panic("test failure");
	13930	expect(v[30] == 1016) catch @panic("test failure");
	13931	expect(v[31] == 1017) catch @panic("test failure");
	13932	expect(v[32] == 1018) catch @panic("test failure");
	13933	expect(v[33] == 1019) catch @panic("test failure");
	13934	expect(v[34] == 1020) catch @panic("test failure");
	13935	expect(v[35] == 1021) catch @panic("test failure");
	13936	expect(v[36] == 1022) catch @panic("test failure");
	13937	expect(v[37] == 1023) catch @panic("test failure");
	13938	expect(v[38] == 1024) catch @panic("test failure");
	13939	expect(v[39] == 1025) catch @panic("test failure");
	13940	expect(v[40] == 1026) catch @panic("test failure");
	13941	expect(v[41] == 1027) catch @panic("test failure");
	13942	expect(v[42] == 1028) catch @panic("test failure");
	13943	expect(v[43] == 1029) catch @panic("test failure");
	13944	expect(v[44] == 1030) catch @panic("test failure");
	13945	expect(v[45] == 1031) catch @panic("test failure");
	13946	expect(v[46] == 1032) catch @panic("test failure");
	13947	expect(v[47] == 1033) catch @panic("test failure");
	13948	expect(v[48] == 1034) catch @panic("test failure");
	13949	expect(v[49] == 1035) catch @panic("test failure");
	13950	expect(v[50] == 1036) catch @panic("test failure");
	13951	expect(v[51] == 1037) catch @panic("test failure");
	13952	expect(v[52] == 1038) catch @panic("test failure");
	13953	expect(v[53] == 1039) catch @panic("test failure");
	13954	expect(v[54] == 1040) catch @panic("test failure");
	13955	expect(v[55] == 1041) catch @panic("test failure");
	13956	expect(v[56] == 1042) catch @panic("test failure");
	13957	expect(v[57] == 1043) catch @panic("test failure");
	13958	expect(v[58] == 1044) catch @panic("test failure");
	13959	expect(v[59] == 1045) catch @panic("test failure");
	13960	expect(v[60] == 1046) catch @panic("test failure");
	13961	expect(v[61] == 1047) catch @panic("test failure");
	13962	expect(v[62] == 1048) catch @panic("test failure");
	13963	expect(v[63] == 1049) catch @panic("test failure");
	13964	expect(v[64] == 1050) catch @panic("test failure");
	13965	expect(v[65] == 1051) catch @panic("test failure");
	13966	expect(v[66] == 1052) catch @panic("test failure");
	13967	expect(v[67] == 1053) catch @panic("test failure");
	13968	expect(v[68] == 1054) catch @panic("test failure");
	13969	expect(v[69] == 1055) catch @panic("test failure");
	13970	expect(v[70] == 1056) catch @panic("test failure");
	13971	expect(v[71] == 1057) catch @panic("test failure");
	13972	expect(v[72] == 1058) catch @panic("test failure");
	13973	expect(v[73] == 1059) catch @panic("test failure");
	13974	expect(v[74] == 1060) catch @panic("test failure");
	13975	expect(v[75] == 1061) catch @panic("test failure");
	13976	expect(v[76] == 1062) catch @panic("test failure");
	13977	expect(v[77] == 1063) catch @panic("test failure");
	13978	expect(v[78] == 1064) catch @panic("test failure");
	13979	expect(v[79] == 1065) catch @panic("test failure");
	13980	expect(v[80] == 1066) catch @panic("test failure");
	13981	expect(v[81] == 1067) catch @panic("test failure");
	13982	expect(v[82] == 1068) catch @panic("test failure");
	13983	expect(v[83] == 1069) catch @panic("test failure");
	13984	expect(v[84] == 1070) catch @panic("test failure");
	13985	expect(v[85] == 1071) catch @panic("test failure");
	13986	expect(v[86] == 1072) catch @panic("test failure");
	13987	expect(v[87] == 1073) catch @panic("test failure");
	13988	expect(v[88] == 1074) catch @panic("test failure");
	13989	expect(v[89] == 1075) catch @panic("test failure");
	13990	expect(v[90] == 1076) catch @panic("test failure");
	13991	expect(v[91] == 1077) catch @panic("test failure");
	13992	expect(v[92] == 1078) catch @panic("test failure");
	13993	expect(v[93] == 1079) catch @panic("test failure");
	13994	expect(v[94] == 1080) catch @panic("test failure");
	13995	expect(v[95] == 1081) catch @panic("test failure");
	13996	expect(i == 96) catch @panic("test failure");
	13997	}
	13998
	13999	extern fn c_ret_vector_96_f32() @Vector(96, f32);
	14000	extern fn c_vector_96_f32(@Vector(96, f32), usize) void;
	14001	extern fn c_test_vector_96_f32() void;
	14002
	14003	test "@Vector(96, f32)" {
	14004	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	14005	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14006	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	14007	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	14008	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	14009
	14010	const v = c_ret_vector_96_f32();
	14011	try expect(v[0] == 1082);
	14012	try expect(v[1] == 1083);
	14013	try expect(v[2] == 1084);
	14014	try expect(v[3] == 1085);
	14015	try expect(v[4] == 1086);
	14016	try expect(v[5] == 1087);
	14017	try expect(v[6] == 1088);
	14018	try expect(v[7] == 1089);
	14019	try expect(v[8] == 1090);
	14020	try expect(v[9] == 1091);
	14021	try expect(v[10] == 1092);
	14022	try expect(v[11] == 1093);
	14023	try expect(v[12] == 1094);
	14024	try expect(v[13] == 1095);
	14025	try expect(v[14] == 1096);
	14026	try expect(v[15] == 1097);
	14027	try expect(v[16] == 1098);
	14028	try expect(v[17] == 1099);
	14029	try expect(v[18] == 1100);
	14030	try expect(v[19] == 1101);
	14031	try expect(v[20] == 1102);
	14032	try expect(v[21] == 1103);
	14033	try expect(v[22] == 1104);
	14034	try expect(v[23] == 1105);
	14035	try expect(v[24] == 1106);
	14036	try expect(v[25] == 1107);
	14037	try expect(v[26] == 1108);
	14038	try expect(v[27] == 1109);
	14039	try expect(v[28] == 1110);
	14040	try expect(v[29] == 1111);
	14041	try expect(v[30] == 1112);
	14042	try expect(v[31] == 1113);
	14043	try expect(v[32] == 1114);
	14044	try expect(v[33] == 1115);
	14045	try expect(v[34] == 1116);
	14046	try expect(v[35] == 1117);
	14047	try expect(v[36] == 1118);
	14048	try expect(v[37] == 1119);
	14049	try expect(v[38] == 1120);
	14050	try expect(v[39] == 1121);
	14051	try expect(v[40] == 1122);
	14052	try expect(v[41] == 1123);
	14053	try expect(v[42] == 1124);
	14054	try expect(v[43] == 1125);
	14055	try expect(v[44] == 1126);
	14056	try expect(v[45] == 1127);
	14057	try expect(v[46] == 1128);
	14058	try expect(v[47] == 1129);
	14059	try expect(v[48] == 1130);
	14060	try expect(v[49] == 1131);
	14061	try expect(v[50] == 1132);
	14062	try expect(v[51] == 1133);
	14063	try expect(v[52] == 1134);
	14064	try expect(v[53] == 1135);
	14065	try expect(v[54] == 1136);
	14066	try expect(v[55] == 1137);
	14067	try expect(v[56] == 1138);
	14068	try expect(v[57] == 1139);
	14069	try expect(v[58] == 1140);
	14070	try expect(v[59] == 1141);
	14071	try expect(v[60] == 1142);
	14072	try expect(v[61] == 1143);
	14073	try expect(v[62] == 1144);
	14074	try expect(v[63] == 1145);
	14075	try expect(v[64] == 1146);
	14076	try expect(v[65] == 1147);
	14077	try expect(v[66] == 1148);
	14078	try expect(v[67] == 1149);
	14079	try expect(v[68] == 1150);
	14080	try expect(v[69] == 1151);
	14081	try expect(v[70] == 1152);
	14082	try expect(v[71] == 1153);
	14083	try expect(v[72] == 1154);
	14084	try expect(v[73] == 1155);
	14085	try expect(v[74] == 1156);
	14086	try expect(v[75] == 1157);
	14087	try expect(v[76] == 1158);
	14088	try expect(v[77] == 1159);
	14089	try expect(v[78] == 1160);
	14090	try expect(v[79] == 1161);
	14091	try expect(v[80] == 1162);
	14092	try expect(v[81] == 1163);
	14093	try expect(v[82] == 1164);
	14094	try expect(v[83] == 1165);
	14095	try expect(v[84] == 1166);
	14096	try expect(v[85] == 1167);
	14097	try expect(v[86] == 1168);
	14098	try expect(v[87] == 1169);
	14099	try expect(v[88] == 1170);
	14100	try expect(v[89] == 1171);
	14101	try expect(v[90] == 1172);
	14102	try expect(v[91] == 1173);
	14103	try expect(v[92] == 1174);
	14104	try expect(v[93] == 1175);
	14105	try expect(v[94] == 1176);
	14106	try expect(v[95] == 1177);
	14107	c_vector_96_f32(.{
	14108	1178, 1179, 1180, 1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 1192, 1193,
	14109	1194, 1195, 1196, 1197, 1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 1206, 1207, 1208, 1209,
	14110	1210, 1211, 1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223, 1224, 1225,
	14111	1226, 1227, 1228, 1229, 1230, 1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 1239, 1240, 1241,
	14112	1242, 1243, 1244, 1245, 1246, 1247, 1248, 1249, 1250, 1251, 1252, 1253, 1254, 1255, 1256, 1257,
	14113	1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 1266, 1267, 1268, 1269, 1270, 1271, 1272, 1273,
	14114	}, 96);
	14115	c_test_vector_96_f32();
	14116	}
	14117
	14118	export fn zig_ret_vector_128_f32() @Vector(128, f32) {
	14119	return .{
	14120	1274, 1275, 1276, 1277, 1278, 1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 1287, 1288, 1289,
	14121	1290, 1291, 1292, 1293, 1294, 1295, 1296, 1297, 1298, 1299, 1300, 1301, 1302, 1303, 1304, 1305,
	14122	1306, 1307, 1308, 1309, 1310, 1311, 1312, 1313, 1314, 1315, 1316, 1317, 1318, 1319, 1320, 1321,
	14123	1322, 1323, 1324, 1325, 1326, 1327, 1328, 1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 1337,
	14124	1338, 1339, 1340, 1341, 1342, 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1350, 1351, 1352, 1353,
	14125	1354, 1355, 1356, 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1365, 1366, 1367, 1368, 1369,
	14126	1370, 1371, 1372, 1373, 1374, 1375, 1376, 1377, 1378, 1379, 1380, 1381, 1382, 1383, 1384, 1385,
	14127	1386, 1387, 1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 1398, 1399, 1400, 1401,
	14128	};
	14129	}
	14130	export fn zig_vector_128_f32(v: @Vector(128, f32), i: usize) void {
	14131	expect(v[0] == 1402) catch @panic("test failure");
	14132	expect(v[1] == 1403) catch @panic("test failure");
	14133	expect(v[2] == 1404) catch @panic("test failure");
	14134	expect(v[3] == 1405) catch @panic("test failure");
	14135	expect(v[4] == 1406) catch @panic("test failure");
	14136	expect(v[5] == 1407) catch @panic("test failure");
	14137	expect(v[6] == 1408) catch @panic("test failure");
	14138	expect(v[7] == 1409) catch @panic("test failure");
	14139	expect(v[8] == 1410) catch @panic("test failure");
	14140	expect(v[9] == 1411) catch @panic("test failure");
	14141	expect(v[10] == 1412) catch @panic("test failure");
	14142	expect(v[11] == 1413) catch @panic("test failure");
	14143	expect(v[12] == 1414) catch @panic("test failure");
	14144	expect(v[13] == 1415) catch @panic("test failure");
	14145	expect(v[14] == 1416) catch @panic("test failure");
	14146	expect(v[15] == 1417) catch @panic("test failure");
	14147	expect(v[16] == 1418) catch @panic("test failure");
	14148	expect(v[17] == 1419) catch @panic("test failure");
	14149	expect(v[18] == 1420) catch @panic("test failure");
	14150	expect(v[19] == 1421) catch @panic("test failure");
	14151	expect(v[20] == 1422) catch @panic("test failure");
	14152	expect(v[21] == 1423) catch @panic("test failure");
	14153	expect(v[22] == 1424) catch @panic("test failure");
	14154	expect(v[23] == 1425) catch @panic("test failure");
	14155	expect(v[24] == 1426) catch @panic("test failure");
	14156	expect(v[25] == 1427) catch @panic("test failure");
	14157	expect(v[26] == 1428) catch @panic("test failure");
	14158	expect(v[27] == 1429) catch @panic("test failure");
	14159	expect(v[28] == 1430) catch @panic("test failure");
	14160	expect(v[29] == 1431) catch @panic("test failure");
	14161	expect(v[30] == 1432) catch @panic("test failure");
	14162	expect(v[31] == 1433) catch @panic("test failure");
	14163	expect(v[32] == 1434) catch @panic("test failure");
	14164	expect(v[33] == 1435) catch @panic("test failure");
	14165	expect(v[34] == 1436) catch @panic("test failure");
	14166	expect(v[35] == 1437) catch @panic("test failure");
	14167	expect(v[36] == 1438) catch @panic("test failure");
	14168	expect(v[37] == 1439) catch @panic("test failure");
	14169	expect(v[38] == 1440) catch @panic("test failure");
	14170	expect(v[39] == 1441) catch @panic("test failure");
	14171	expect(v[40] == 1442) catch @panic("test failure");
	14172	expect(v[41] == 1443) catch @panic("test failure");
	14173	expect(v[42] == 1444) catch @panic("test failure");
	14174	expect(v[43] == 1445) catch @panic("test failure");
	14175	expect(v[44] == 1446) catch @panic("test failure");
	14176	expect(v[45] == 1447) catch @panic("test failure");
	14177	expect(v[46] == 1448) catch @panic("test failure");
	14178	expect(v[47] == 1449) catch @panic("test failure");
	14179	expect(v[48] == 1450) catch @panic("test failure");
	14180	expect(v[49] == 1451) catch @panic("test failure");
	14181	expect(v[50] == 1452) catch @panic("test failure");
	14182	expect(v[51] == 1453) catch @panic("test failure");
	14183	expect(v[52] == 1454) catch @panic("test failure");
	14184	expect(v[53] == 1455) catch @panic("test failure");
	14185	expect(v[54] == 1456) catch @panic("test failure");
	14186	expect(v[55] == 1457) catch @panic("test failure");
	14187	expect(v[56] == 1458) catch @panic("test failure");
	14188	expect(v[57] == 1459) catch @panic("test failure");
	14189	expect(v[58] == 1460) catch @panic("test failure");
	14190	expect(v[59] == 1461) catch @panic("test failure");
	14191	expect(v[60] == 1462) catch @panic("test failure");
	14192	expect(v[61] == 1463) catch @panic("test failure");
	14193	expect(v[62] == 1464) catch @panic("test failure");
	14194	expect(v[63] == 1465) catch @panic("test failure");
	14195	expect(v[64] == 1466) catch @panic("test failure");
	14196	expect(v[65] == 1467) catch @panic("test failure");
	14197	expect(v[66] == 1468) catch @panic("test failure");
	14198	expect(v[67] == 1469) catch @panic("test failure");
	14199	expect(v[68] == 1470) catch @panic("test failure");
	14200	expect(v[69] == 1471) catch @panic("test failure");
	14201	expect(v[70] == 1472) catch @panic("test failure");
	14202	expect(v[71] == 1473) catch @panic("test failure");
	14203	expect(v[72] == 1474) catch @panic("test failure");
	14204	expect(v[73] == 1475) catch @panic("test failure");
	14205	expect(v[74] == 1476) catch @panic("test failure");
	14206	expect(v[75] == 1477) catch @panic("test failure");
	14207	expect(v[76] == 1478) catch @panic("test failure");
	14208	expect(v[77] == 1479) catch @panic("test failure");
	14209	expect(v[78] == 1480) catch @panic("test failure");
	14210	expect(v[79] == 1481) catch @panic("test failure");
	14211	expect(v[80] == 1482) catch @panic("test failure");
	14212	expect(v[81] == 1483) catch @panic("test failure");
	14213	expect(v[82] == 1484) catch @panic("test failure");
	14214	expect(v[83] == 1485) catch @panic("test failure");
	14215	expect(v[84] == 1486) catch @panic("test failure");
	14216	expect(v[85] == 1487) catch @panic("test failure");
	14217	expect(v[86] == 1488) catch @panic("test failure");
	14218	expect(v[87] == 1489) catch @panic("test failure");
	14219	expect(v[88] == 1490) catch @panic("test failure");
	14220	expect(v[89] == 1491) catch @panic("test failure");
	14221	expect(v[90] == 1492) catch @panic("test failure");
	14222	expect(v[91] == 1493) catch @panic("test failure");
	14223	expect(v[92] == 1494) catch @panic("test failure");
	14224	expect(v[93] == 1495) catch @panic("test failure");
	14225	expect(v[94] == 1496) catch @panic("test failure");
	14226	expect(v[95] == 1497) catch @panic("test failure");
	14227	expect(v[96] == 1498) catch @panic("test failure");
	14228	expect(v[97] == 1499) catch @panic("test failure");
	14229	expect(v[98] == 1500) catch @panic("test failure");
	14230	expect(v[99] == 1501) catch @panic("test failure");
	14231	expect(v[100] == 1502) catch @panic("test failure");
	14232	expect(v[101] == 1503) catch @panic("test failure");
	14233	expect(v[102] == 1504) catch @panic("test failure");
	14234	expect(v[103] == 1505) catch @panic("test failure");
	14235	expect(v[104] == 1506) catch @panic("test failure");
	14236	expect(v[105] == 1507) catch @panic("test failure");
	14237	expect(v[106] == 1508) catch @panic("test failure");
	14238	expect(v[107] == 1509) catch @panic("test failure");
	14239	expect(v[108] == 1510) catch @panic("test failure");
	14240	expect(v[109] == 1511) catch @panic("test failure");
	14241	expect(v[110] == 1512) catch @panic("test failure");
	14242	expect(v[111] == 1513) catch @panic("test failure");
	14243	expect(v[112] == 1514) catch @panic("test failure");
	14244	expect(v[113] == 1515) catch @panic("test failure");
	14245	expect(v[114] == 1516) catch @panic("test failure");
	14246	expect(v[115] == 1517) catch @panic("test failure");
	14247	expect(v[116] == 1518) catch @panic("test failure");
	14248	expect(v[117] == 1519) catch @panic("test failure");
	14249	expect(v[118] == 1520) catch @panic("test failure");
	14250	expect(v[119] == 1521) catch @panic("test failure");
	14251	expect(v[120] == 1522) catch @panic("test failure");
	14252	expect(v[121] == 1523) catch @panic("test failure");
	14253	expect(v[122] == 1524) catch @panic("test failure");
	14254	expect(v[123] == 1525) catch @panic("test failure");
	14255	expect(v[124] == 1526) catch @panic("test failure");
	14256	expect(v[125] == 1527) catch @panic("test failure");
	14257	expect(v[126] == 1528) catch @panic("test failure");
	14258	expect(v[127] == 1529) catch @panic("test failure");
	14259	expect(i == 128) catch @panic("test failure");
	14260	}
	14261
	14262	extern fn c_ret_vector_128_f32() @Vector(128, f32);
	14263	extern fn c_vector_128_f32(@Vector(128, f32), usize) void;
	14264	extern fn c_test_vector_128_f32() void;
	14265
	14266	test "@Vector(128, f32)" {
	14267	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	14268	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14269	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	14270	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	14271	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	14272
	14273	const v = c_ret_vector_128_f32();
	14274	try expect(v[0] == 1530);
	14275	try expect(v[1] == 1531);
	14276	try expect(v[2] == 1532);
	14277	try expect(v[3] == 1533);
	14278	try expect(v[4] == 1534);
	14279	try expect(v[5] == 1535);
	14280	try expect(v[6] == 1536);
	14281	try expect(v[7] == 1537);
	14282	try expect(v[8] == 1538);
	14283	try expect(v[9] == 1539);
	14284	try expect(v[10] == 1540);
	14285	try expect(v[11] == 1541);
	14286	try expect(v[12] == 1542);
	14287	try expect(v[13] == 1543);
	14288	try expect(v[14] == 1544);
	14289	try expect(v[15] == 1545);
	14290	try expect(v[16] == 1546);
	14291	try expect(v[17] == 1547);
	14292	try expect(v[18] == 1548);
	14293	try expect(v[19] == 1549);
	14294	try expect(v[20] == 1550);
	14295	try expect(v[21] == 1551);
	14296	try expect(v[22] == 1552);
	14297	try expect(v[23] == 1553);
	14298	try expect(v[24] == 1554);
	14299	try expect(v[25] == 1555);
	14300	try expect(v[26] == 1556);
	14301	try expect(v[27] == 1557);
	14302	try expect(v[28] == 1558);
	14303	try expect(v[29] == 1559);
	14304	try expect(v[30] == 1560);
	14305	try expect(v[31] == 1561);
	14306	try expect(v[32] == 1562);
	14307	try expect(v[33] == 1563);
	14308	try expect(v[34] == 1564);
	14309	try expect(v[35] == 1565);
	14310	try expect(v[36] == 1566);
	14311	try expect(v[37] == 1567);
	14312	try expect(v[38] == 1568);
	14313	try expect(v[39] == 1569);
	14314	try expect(v[40] == 1570);
	14315	try expect(v[41] == 1571);
	14316	try expect(v[42] == 1572);
	14317	try expect(v[43] == 1573);
	14318	try expect(v[44] == 1574);
	14319	try expect(v[45] == 1575);
	14320	try expect(v[46] == 1576);
	14321	try expect(v[47] == 1577);
	14322	try expect(v[48] == 1578);
	14323	try expect(v[49] == 1579);
	14324	try expect(v[50] == 1580);
	14325	try expect(v[51] == 1581);
	14326	try expect(v[52] == 1582);
	14327	try expect(v[53] == 1583);
	14328	try expect(v[54] == 1584);
	14329	try expect(v[55] == 1585);
	14330	try expect(v[56] == 1586);
	14331	try expect(v[57] == 1587);
	14332	try expect(v[58] == 1588);
	14333	try expect(v[59] == 1589);
	14334	try expect(v[60] == 1590);
	14335	try expect(v[61] == 1591);
	14336	try expect(v[62] == 1592);
	14337	try expect(v[63] == 1593);
	14338	try expect(v[64] == 1594);
	14339	try expect(v[65] == 1595);
	14340	try expect(v[66] == 1596);
	14341	try expect(v[67] == 1597);
	14342	try expect(v[68] == 1598);
	14343	try expect(v[69] == 1599);
	14344	try expect(v[70] == 1600);
	14345	try expect(v[71] == 1601);
	14346	try expect(v[72] == 1602);
	14347	try expect(v[73] == 1603);
	14348	try expect(v[74] == 1604);
	14349	try expect(v[75] == 1605);
	14350	try expect(v[76] == 1606);
	14351	try expect(v[77] == 1607);
	14352	try expect(v[78] == 1608);
	14353	try expect(v[79] == 1609);
	14354	try expect(v[80] == 1610);
	14355	try expect(v[81] == 1611);
	14356	try expect(v[82] == 1612);
	14357	try expect(v[83] == 1613);
	14358	try expect(v[84] == 1614);
	14359	try expect(v[85] == 1615);
	14360	try expect(v[86] == 1616);
	14361	try expect(v[87] == 1617);
	14362	try expect(v[88] == 1618);
	14363	try expect(v[89] == 1619);
	14364	try expect(v[90] == 1620);
	14365	try expect(v[91] == 1621);
	14366	try expect(v[92] == 1622);
	14367	try expect(v[93] == 1623);
	14368	try expect(v[94] == 1624);
	14369	try expect(v[95] == 1625);
	14370	try expect(v[96] == 1626);
	14371	try expect(v[97] == 1627);
	14372	try expect(v[98] == 1628);
	14373	try expect(v[99] == 1629);
	14374	try expect(v[100] == 1630);
	14375	try expect(v[101] == 1631);
	14376	try expect(v[102] == 1632);
	14377	try expect(v[103] == 1633);
	14378	try expect(v[104] == 1634);
	14379	try expect(v[105] == 1635);
	14380	try expect(v[106] == 1636);
	14381	try expect(v[107] == 1637);
	14382	try expect(v[108] == 1638);
	14383	try expect(v[109] == 1639);
	14384	try expect(v[110] == 1640);
	14385	try expect(v[111] == 1641);
	14386	try expect(v[112] == 1642);
	14387	try expect(v[113] == 1643);
	14388	try expect(v[114] == 1644);
	14389	try expect(v[115] == 1645);
	14390	try expect(v[116] == 1646);
	14391	try expect(v[117] == 1647);
	14392	try expect(v[118] == 1648);
	14393	try expect(v[119] == 1649);
	14394	try expect(v[120] == 1650);
	14395	try expect(v[121] == 1651);
	14396	try expect(v[122] == 1652);
	14397	try expect(v[123] == 1653);
	14398	try expect(v[124] == 1654);
	14399	try expect(v[125] == 1655);
	14400	try expect(v[126] == 1656);
	14401	try expect(v[127] == 1657);
	14402	c_vector_128_f32(.{
	14403	1658, 1659, 1660, 1661, 1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 1670, 1671, 1672, 1673,
	14404	1674, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689,
	14405	1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 1698, 1699, 1700, 1701, 1702, 1703, 1704, 1705,
	14406	1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721,
	14407	1722, 1723, 1724, 1725, 1726, 1727, 1728, 1729, 1730, 1731, 1732, 1733, 1734, 1735, 1736, 1737,
	14408	1738, 1739, 1740, 1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 1749, 1750, 1751, 1752, 1753,
	14409	1754, 1755, 1756, 1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769,
	14410	1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 1783, 1784, 1785,
	14411	}, 128);
	14412	c_test_vector_128_f32();
	14413	}
	14414
	14415	export fn zig_ret_vector_1_f64() @Vector(1, f64) {
	14416	return .{1};
	14417	}
	14418	export fn zig_vector_1_f64(v: @Vector(1, f64), i: usize) void {
	14419	expect(v[0] == 2) catch @panic("test failure");
	14420	expect(i == 1) catch @panic("test failure");
	14421	}
	14422
	14423	extern fn c_ret_vector_1_f64() @Vector(1, f64);
	14424	extern fn c_vector_1_f64(@Vector(1, f64), usize) void;
	14425	extern fn c_test_vector_1_f64() void;
	14426
	14427	test "@Vector(1, f64)" {
	14428	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14429	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	14430
	14431	const v = c_ret_vector_1_f64();
	14432	try expect(v[0] == 3);
	14433	c_vector_1_f64(.{4}, 1);
	14434	c_test_vector_1_f64();
	14435	}
	14436
	14437	export fn zig_ret_vector_2_f64() @Vector(2, f64) {
	14438	return .{ 5, 6 };
	14439	}
	14440	export fn zig_vector_2_f64(v: @Vector(2, f64), i: usize) void {
	14441	expect(v[0] == 7) catch @panic("test failure");
	14442	expect(v[1] == 8) catch @panic("test failure");
	14443	expect(i == 2) catch @panic("test failure");
	14444	}
	14445
	14446	extern fn c_ret_vector_2_f64() @Vector(2, f64);
	14447	extern fn c_vector_2_f64(@Vector(2, f64), usize) void;
	14448	extern fn c_test_vector_2_f64() void;
	14449
	14450	test "@Vector(2, f64)" {
	14451	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14452
	14453	const v = c_ret_vector_2_f64();
	14454	try expect(v[0] == 9);
	14455	try expect(v[1] == 10);
	14456	c_vector_2_f64(.{ 11, 12 }, 2);
	14457	c_test_vector_2_f64();
	14458	}
	14459
	14460	export fn zig_ret_vector_3_f64() @Vector(3, f64) {
	14461	return .{ 13, 14, 15 };
	14462	}
	14463	export fn zig_vector_3_f64(v: @Vector(3, f64), i: usize) void {
	14464	expect(v[0] == 16) catch @panic("test failure");
	14465	expect(v[1] == 17) catch @panic("test failure");
	14466	expect(v[2] == 18) catch @panic("test failure");
	14467	expect(i == 3) catch @panic("test failure");
	14468	}
	14469
	14470	extern fn c_ret_vector_3_f64() @Vector(3, f64);
	14471	extern fn c_vector_3_f64(@Vector(3, f64), usize) void;
	14472	extern fn c_test_vector_3_f64() void;
	14473
	14474	test "@Vector(3, f64)" {
	14475	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	14476	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14477	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	14478	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	14479	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	14480
	14481	const v = c_ret_vector_3_f64();
	14482	try expect(v[0] == 19);
	14483	try expect(v[1] == 20);
	14484	try expect(v[2] == 21);
	14485	c_vector_3_f64(.{ 22, 23, 24 }, 3);
	14486	c_test_vector_3_f64();
	14487	}
	14488
	14489	export fn zig_ret_vector_4_f64() @Vector(4, f64) {
	14490	return .{ 25, 26, 27, 28 };
	14491	}
	14492	export fn zig_vector_4_f64(v: @Vector(4, f64), i: usize) void {
	14493	expect(v[0] == 29) catch @panic("test failure");
	14494	expect(v[1] == 30) catch @panic("test failure");
	14495	expect(v[2] == 31) catch @panic("test failure");
	14496	expect(v[3] == 32) catch @panic("test failure");
	14497	expect(i == 4) catch @panic("test failure");
	14498	}
	14499
	14500	extern fn c_ret_vector_4_f64() @Vector(4, f64);
	14501	extern fn c_vector_4_f64(@Vector(4, f64), usize) void;
	14502	extern fn c_test_vector_4_f64() void;
	14503
	14504	test "@Vector(4, f64)" {
	14505	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14506	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	14507	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	14508	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	14509
	14510	const v = c_ret_vector_4_f64();
	14511	try expect(v[0] == 33);
	14512	try expect(v[1] == 34);
	14513	try expect(v[2] == 35);
	14514	try expect(v[3] == 36);
	14515	c_vector_4_f64(.{ 37, 38, 39, 40 }, 4);
	14516	c_test_vector_4_f64();
	14517	}
	14518
	14519	export fn zig_ret_vector_6_f64() @Vector(6, f64) {
	14520	return .{ 41, 42, 43, 44, 45, 46 };
	14521	}
	14522	export fn zig_vector_6_f64(v: @Vector(6, f64), i: usize) void {
	14523	expect(v[0] == 47) catch @panic("test failure");
	14524	expect(v[1] == 48) catch @panic("test failure");
	14525	expect(v[2] == 49) catch @panic("test failure");
	14526	expect(v[3] == 50) catch @panic("test failure");
	14527	expect(v[4] == 51) catch @panic("test failure");
	14528	expect(v[5] == 52) catch @panic("test failure");
	14529	expect(i == 6) catch @panic("test failure");
	14530	}
	14531
	14532	extern fn c_ret_vector_6_f64() @Vector(6, f64);
	14533	extern fn c_vector_6_f64(@Vector(6, f64), usize) void;
	14534	extern fn c_test_vector_6_f64() void;
	14535
	14536	test "@Vector(6, f64)" {
	14537	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	14538	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14539	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	14540	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	14541	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	14542
	14543	const v = c_ret_vector_6_f64();
	14544	try expect(v[0] == 53);
	14545	try expect(v[1] == 54);
	14546	try expect(v[2] == 55);
	14547	try expect(v[3] == 56);
	14548	try expect(v[4] == 57);
	14549	try expect(v[5] == 58);
	14550	c_vector_6_f64(.{ 59, 60, 61, 62, 63, 64 }, 6);
	14551	c_test_vector_6_f64();
	14552	}
	14553
	14554	export fn zig_ret_vector_8_f64() @Vector(8, f64) {
	14555	return .{ 65, 66, 67, 68, 69, 70, 71, 72 };
	14556	}
	14557	export fn zig_vector_8_f64(v: @Vector(8, f64), i: usize) void {
	14558	expect(v[0] == 73) catch @panic("test failure");
	14559	expect(v[1] == 74) catch @panic("test failure");
	14560	expect(v[2] == 75) catch @panic("test failure");
	14561	expect(v[3] == 76) catch @panic("test failure");
	14562	expect(v[4] == 77) catch @panic("test failure");
	14563	expect(v[5] == 78) catch @panic("test failure");
	14564	expect(v[6] == 79) catch @panic("test failure");
	14565	expect(v[7] == 80) catch @panic("test failure");
	14566	expect(i == 8) catch @panic("test failure");
	14567	}
	14568
	14569	extern fn c_ret_vector_8_f64() @Vector(8, f64);
	14570	extern fn c_vector_8_f64(@Vector(8, f64), usize) void;
	14571	extern fn c_test_vector_8_f64() void;
	14572
	14573	test "@Vector(8, f64)" {
	14574	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14575	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	14576	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	14577	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	14578
	14579	const v = c_ret_vector_8_f64();
	14580	try expect(v[0] == 81);
	14581	try expect(v[1] == 82);
	14582	try expect(v[2] == 83);
	14583	try expect(v[3] == 84);
	14584	try expect(v[4] == 85);
	14585	try expect(v[5] == 86);
	14586	try expect(v[6] == 87);
	14587	try expect(v[7] == 88);
	14588	c_vector_8_f64(.{ 89, 90, 91, 92, 93, 94, 95, 96 }, 8);
	14589	c_test_vector_8_f64();
	14590	}
	14591
	14592	export fn zig_ret_vector_12_f64() @Vector(12, f64) {
	14593	return .{ 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108 };
	14594	}
	14595	export fn zig_vector_12_f64(v: @Vector(12, f64), i: usize) void {
	14596	expect(v[0] == 109) catch @panic("test failure");
	14597	expect(v[1] == 110) catch @panic("test failure");
	14598	expect(v[2] == 111) catch @panic("test failure");
	14599	expect(v[3] == 112) catch @panic("test failure");
	14600	expect(v[4] == 113) catch @panic("test failure");
	14601	expect(v[5] == 114) catch @panic("test failure");
	14602	expect(v[6] == 115) catch @panic("test failure");
	14603	expect(v[7] == 116) catch @panic("test failure");
	14604	expect(v[8] == 117) catch @panic("test failure");
	14605	expect(v[9] == 118) catch @panic("test failure");
	14606	expect(v[10] == 119) catch @panic("test failure");
	14607	expect(v[11] == 120) catch @panic("test failure");
	14608	expect(i == 12) catch @panic("test failure");
	14609	}
	14610
	14611	extern fn c_ret_vector_12_f64() @Vector(12, f64);
	14612	extern fn c_vector_12_f64(@Vector(12, f64), usize) void;
	14613	extern fn c_test_vector_12_f64() void;
	14614
	14615	test "@Vector(12, f64)" {
	14616	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	14617	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14618	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	14619	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	14620	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	14621
	14622	const v = c_ret_vector_12_f64();
	14623	try expect(v[0] == 121);
	14624	try expect(v[1] == 122);
	14625	try expect(v[2] == 123);
	14626	try expect(v[3] == 124);
	14627	try expect(v[4] == 125);
	14628	try expect(v[5] == 126);
	14629	try expect(v[6] == 127);
	14630	try expect(v[7] == 128);
	14631	try expect(v[8] == 129);
	14632	try expect(v[9] == 130);
	14633	try expect(v[10] == 131);
	14634	try expect(v[11] == 132);
	14635	c_vector_12_f64(.{ 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144 }, 12);
	14636	c_test_vector_12_f64();
	14637	}
	14638
	14639	export fn zig_ret_vector_16_f64() @Vector(16, f64) {
	14640	return .{ 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160 };
	14641	}
	14642	export fn zig_vector_16_f64(v: @Vector(16, f64), i: usize) void {
	14643	expect(v[0] == 161) catch @panic("test failure");
	14644	expect(v[1] == 162) catch @panic("test failure");
	14645	expect(v[2] == 163) catch @panic("test failure");
	14646	expect(v[3] == 164) catch @panic("test failure");
	14647	expect(v[4] == 165) catch @panic("test failure");
	14648	expect(v[5] == 166) catch @panic("test failure");
	14649	expect(v[6] == 167) catch @panic("test failure");
	14650	expect(v[7] == 168) catch @panic("test failure");
	14651	expect(v[8] == 169) catch @panic("test failure");
	14652	expect(v[9] == 170) catch @panic("test failure");
	14653	expect(v[10] == 171) catch @panic("test failure");
	14654	expect(v[11] == 172) catch @panic("test failure");
	14655	expect(v[12] == 173) catch @panic("test failure");
	14656	expect(v[13] == 174) catch @panic("test failure");
	14657	expect(v[14] == 175) catch @panic("test failure");
	14658	expect(v[15] == 176) catch @panic("test failure");
	14659	expect(i == 16) catch @panic("test failure");
	14660	}
	14661
	14662	extern fn c_ret_vector_16_f64() @Vector(16, f64);
	14663	extern fn c_vector_16_f64(@Vector(16, f64), usize) void;
	14664	extern fn c_test_vector_16_f64() void;
	14665
	14666	test "@Vector(16, f64)" {
	14667	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	14668	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14669	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	14670	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	14671	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	14672
	14673	const v = c_ret_vector_16_f64();
	14674	try expect(v[0] == 177);
	14675	try expect(v[1] == 178);
	14676	try expect(v[2] == 179);
	14677	try expect(v[3] == 180);
	14678	try expect(v[4] == 181);
	14679	try expect(v[5] == 182);
	14680	try expect(v[6] == 183);
	14681	try expect(v[7] == 184);
	14682	try expect(v[8] == 185);
	14683	try expect(v[9] == 186);
	14684	try expect(v[10] == 187);
	14685	try expect(v[11] == 188);
	14686	try expect(v[12] == 189);
	14687	try expect(v[13] == 190);
	14688	try expect(v[14] == 191);
	14689	try expect(v[15] == 192);
	14690	c_vector_16_f64(.{ 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 }, 16);
	14691	c_test_vector_16_f64();
	14692	}
	14693
	14694	export fn zig_ret_vector_24_f64() @Vector(24, f64) {
	14695	return .{
	14696	209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224,
	14697	225, 226, 227, 228, 229, 230, 231, 232,
	14698	};
	14699	}
	14700	export fn zig_vector_24_f64(v: @Vector(24, f64), i: usize) void {
	14701	expect(v[0] == 233) catch @panic("test failure");
	14702	expect(v[1] == 234) catch @panic("test failure");
	14703	expect(v[2] == 235) catch @panic("test failure");
	14704	expect(v[3] == 236) catch @panic("test failure");
	14705	expect(v[4] == 237) catch @panic("test failure");
	14706	expect(v[5] == 238) catch @panic("test failure");
	14707	expect(v[6] == 239) catch @panic("test failure");
	14708	expect(v[7] == 240) catch @panic("test failure");
	14709	expect(v[8] == 241) catch @panic("test failure");
	14710	expect(v[9] == 242) catch @panic("test failure");
	14711	expect(v[10] == 243) catch @panic("test failure");
	14712	expect(v[11] == 244) catch @panic("test failure");
	14713	expect(v[12] == 245) catch @panic("test failure");
	14714	expect(v[13] == 246) catch @panic("test failure");
	14715	expect(v[14] == 247) catch @panic("test failure");
	14716	expect(v[15] == 248) catch @panic("test failure");
	14717	expect(v[16] == 249) catch @panic("test failure");
	14718	expect(v[17] == 250) catch @panic("test failure");
	14719	expect(v[18] == 251) catch @panic("test failure");
	14720	expect(v[19] == 252) catch @panic("test failure");
	14721	expect(v[20] == 253) catch @panic("test failure");
	14722	expect(v[21] == 254) catch @panic("test failure");
	14723	expect(v[22] == 255) catch @panic("test failure");
	14724	expect(v[23] == 256) catch @panic("test failure");
	14725	expect(i == 24) catch @panic("test failure");
	14726	}
	14727
	14728	extern fn c_ret_vector_24_f64() @Vector(24, f64);
	14729	extern fn c_vector_24_f64(@Vector(24, f64), usize) void;
	14730	extern fn c_test_vector_24_f64() void;
	14731
	14732	test "@Vector(24, f64)" {
	14733	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	14734	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14735	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	14736	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	14737	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	14738
	14739	const v = c_ret_vector_24_f64();
	14740	try expect(v[0] == 257);
	14741	try expect(v[1] == 258);
	14742	try expect(v[2] == 259);
	14743	try expect(v[3] == 260);
	14744	try expect(v[4] == 261);
	14745	try expect(v[5] == 262);
	14746	try expect(v[6] == 263);
	14747	try expect(v[7] == 264);
	14748	try expect(v[8] == 265);
	14749	try expect(v[9] == 266);
	14750	try expect(v[10] == 267);
	14751	try expect(v[11] == 268);
	14752	try expect(v[12] == 269);
	14753	try expect(v[13] == 270);
	14754	try expect(v[14] == 271);
	14755	try expect(v[15] == 272);
	14756	try expect(v[16] == 273);
	14757	try expect(v[17] == 274);
	14758	try expect(v[18] == 275);
	14759	try expect(v[19] == 276);
	14760	try expect(v[20] == 277);
	14761	try expect(v[21] == 278);
	14762	try expect(v[22] == 279);
	14763	try expect(v[23] == 280);
	14764	c_vector_24_f64(.{
	14765	281, 282, 283, 284, 285, 286, 287, 288, 289, 290, 291, 292, 293, 294, 295, 296,
	14766	297, 298, 299, 300, 301, 302, 303, 304,
	14767	}, 24);
	14768	c_test_vector_24_f64();
	14769	}
	14770
	14771	export fn zig_ret_vector_32_f64() @Vector(32, f64) {
	14772	return .{
	14773	305, 306, 307, 308, 309, 310, 311, 312, 313, 314, 315, 316, 317, 318, 319, 320,
	14774	321, 322, 323, 324, 325, 326, 327, 328, 329, 330, 331, 332, 333, 334, 335, 336,
	14775	};
	14776	}
	14777	export fn zig_vector_32_f64(v: @Vector(32, f64), i: usize) void {
	14778	expect(v[0] == 337) catch @panic("test failure");
	14779	expect(v[1] == 338) catch @panic("test failure");
	14780	expect(v[2] == 339) catch @panic("test failure");
	14781	expect(v[3] == 340) catch @panic("test failure");
	14782	expect(v[4] == 341) catch @panic("test failure");
	14783	expect(v[5] == 342) catch @panic("test failure");
	14784	expect(v[6] == 343) catch @panic("test failure");
	14785	expect(v[7] == 344) catch @panic("test failure");
	14786	expect(v[8] == 345) catch @panic("test failure");
	14787	expect(v[9] == 346) catch @panic("test failure");
	14788	expect(v[10] == 347) catch @panic("test failure");
	14789	expect(v[11] == 348) catch @panic("test failure");
	14790	expect(v[12] == 349) catch @panic("test failure");
	14791	expect(v[13] == 350) catch @panic("test failure");
	14792	expect(v[14] == 351) catch @panic("test failure");
	14793	expect(v[15] == 352) catch @panic("test failure");
	14794	expect(v[16] == 353) catch @panic("test failure");
	14795	expect(v[17] == 354) catch @panic("test failure");
	14796	expect(v[18] == 355) catch @panic("test failure");
	14797	expect(v[19] == 356) catch @panic("test failure");
	14798	expect(v[20] == 357) catch @panic("test failure");
	14799	expect(v[21] == 358) catch @panic("test failure");
	14800	expect(v[22] == 359) catch @panic("test failure");
	14801	expect(v[23] == 360) catch @panic("test failure");
	14802	expect(v[24] == 361) catch @panic("test failure");
	14803	expect(v[25] == 362) catch @panic("test failure");
	14804	expect(v[26] == 363) catch @panic("test failure");
	14805	expect(v[27] == 364) catch @panic("test failure");
	14806	expect(v[28] == 365) catch @panic("test failure");
	14807	expect(v[29] == 366) catch @panic("test failure");
	14808	expect(v[30] == 367) catch @panic("test failure");
	14809	expect(v[31] == 368) catch @panic("test failure");
	14810	expect(i == 32) catch @panic("test failure");
	14811	}
	14812
	14813	extern fn c_ret_vector_32_f64() @Vector(32, f64);
	14814	extern fn c_vector_32_f64(@Vector(32, f64), usize) void;
	14815	extern fn c_test_vector_32_f64() void;
	14816
	14817	test "@Vector(32, f64)" {
	14818	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	14819	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14820	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	14821	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	14822	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	14823
	14824	const v = c_ret_vector_32_f64();
	14825	try expect(v[0] == 369);
	14826	try expect(v[1] == 370);
	14827	try expect(v[2] == 371);
	14828	try expect(v[3] == 372);
	14829	try expect(v[4] == 373);
	14830	try expect(v[5] == 374);
	14831	try expect(v[6] == 375);
	14832	try expect(v[7] == 376);
	14833	try expect(v[8] == 377);
	14834	try expect(v[9] == 378);
	14835	try expect(v[10] == 379);
	14836	try expect(v[11] == 380);
	14837	try expect(v[12] == 381);
	14838	try expect(v[13] == 382);
	14839	try expect(v[14] == 383);
	14840	try expect(v[15] == 384);
	14841	try expect(v[16] == 385);
	14842	try expect(v[17] == 386);
	14843	try expect(v[18] == 387);
	14844	try expect(v[19] == 388);
	14845	try expect(v[20] == 389);
	14846	try expect(v[21] == 390);
	14847	try expect(v[22] == 391);
	14848	try expect(v[23] == 392);
	14849	try expect(v[24] == 393);
	14850	try expect(v[25] == 394);
	14851	try expect(v[26] == 395);
	14852	try expect(v[27] == 396);
	14853	try expect(v[28] == 397);
	14854	try expect(v[29] == 398);
	14855	try expect(v[30] == 399);
	14856	try expect(v[31] == 400);
	14857	c_vector_32_f64(.{
	14858	401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416,
	14859	417, 418, 419, 420, 421, 422, 423, 424, 425, 426, 427, 428, 429, 430, 431, 432,
	14860	}, 32);
	14861	c_test_vector_32_f64();
	14862	}
	14863
	14864	export fn zig_ret_vector_48_f64() @Vector(48, f64) {
	14865	return .{
	14866	433, 434, 435, 436, 437, 438, 439, 440, 441, 442, 443, 444, 445, 446, 447, 448,
	14867	449, 450, 451, 452, 453, 454, 455, 456, 457, 458, 459, 460, 461, 462, 463, 464,
	14868	465, 466, 467, 468, 469, 470, 471, 472, 473, 474, 475, 476, 477, 478, 479, 480,
	14869	};
	14870	}
	14871	export fn zig_vector_48_f64(v: @Vector(48, f64), i: usize) void {
	14872	expect(v[0] == 481) catch @panic("test failure");
	14873	expect(v[1] == 482) catch @panic("test failure");
	14874	expect(v[2] == 483) catch @panic("test failure");
	14875	expect(v[3] == 484) catch @panic("test failure");
	14876	expect(v[4] == 485) catch @panic("test failure");
	14877	expect(v[5] == 486) catch @panic("test failure");
	14878	expect(v[6] == 487) catch @panic("test failure");
	14879	expect(v[7] == 488) catch @panic("test failure");
	14880	expect(v[8] == 489) catch @panic("test failure");
	14881	expect(v[9] == 490) catch @panic("test failure");
	14882	expect(v[10] == 491) catch @panic("test failure");
	14883	expect(v[11] == 492) catch @panic("test failure");
	14884	expect(v[12] == 493) catch @panic("test failure");
	14885	expect(v[13] == 494) catch @panic("test failure");
	14886	expect(v[14] == 495) catch @panic("test failure");
	14887	expect(v[15] == 496) catch @panic("test failure");
	14888	expect(v[16] == 497) catch @panic("test failure");
	14889	expect(v[17] == 498) catch @panic("test failure");
	14890	expect(v[18] == 499) catch @panic("test failure");
	14891	expect(v[19] == 500) catch @panic("test failure");
	14892	expect(v[20] == 501) catch @panic("test failure");
	14893	expect(v[21] == 502) catch @panic("test failure");
	14894	expect(v[22] == 503) catch @panic("test failure");
	14895	expect(v[23] == 504) catch @panic("test failure");
	14896	expect(v[24] == 505) catch @panic("test failure");
	14897	expect(v[25] == 506) catch @panic("test failure");
	14898	expect(v[26] == 507) catch @panic("test failure");
	14899	expect(v[27] == 508) catch @panic("test failure");
	14900	expect(v[28] == 509) catch @panic("test failure");
	14901	expect(v[29] == 510) catch @panic("test failure");
	14902	expect(v[30] == 511) catch @panic("test failure");
	14903	expect(v[31] == 512) catch @panic("test failure");
	14904	expect(v[32] == 513) catch @panic("test failure");
	14905	expect(v[33] == 514) catch @panic("test failure");
	14906	expect(v[34] == 515) catch @panic("test failure");
	14907	expect(v[35] == 516) catch @panic("test failure");
	14908	expect(v[36] == 517) catch @panic("test failure");
	14909	expect(v[37] == 518) catch @panic("test failure");
	14910	expect(v[38] == 519) catch @panic("test failure");
	14911	expect(v[39] == 520) catch @panic("test failure");
	14912	expect(v[40] == 521) catch @panic("test failure");
	14913	expect(v[41] == 522) catch @panic("test failure");
	14914	expect(v[42] == 523) catch @panic("test failure");
	14915	expect(v[43] == 524) catch @panic("test failure");
	14916	expect(v[44] == 525) catch @panic("test failure");
	14917	expect(v[45] == 526) catch @panic("test failure");
	14918	expect(v[46] == 527) catch @panic("test failure");
	14919	expect(v[47] == 528) catch @panic("test failure");
	14920	expect(i == 48) catch @panic("test failure");
	14921	}
	14922
	14923	extern fn c_ret_vector_48_f64() @Vector(48, f64);
	14924	extern fn c_vector_48_f64(@Vector(48, f64), usize) void;
	14925	extern fn c_test_vector_48_f64() void;
	14926
	14927	test "@Vector(48, f64)" {
	14928	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	14929	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	14930	if (builtin.cpu.arch.isMIPS()) return error.SkipZigTest;
	14931	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	14932	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	14933
	14934	const v = c_ret_vector_48_f64();
	14935	try expect(v[0] == 529);
	14936	try expect(v[1] == 530);
	14937	try expect(v[2] == 531);
	14938	try expect(v[3] == 532);
	14939	try expect(v[4] == 533);
	14940	try expect(v[5] == 534);
	14941	try expect(v[6] == 535);
	14942	try expect(v[7] == 536);
	14943	try expect(v[8] == 537);
	14944	try expect(v[9] == 538);
	14945	try expect(v[10] == 539);
	14946	try expect(v[11] == 540);
	14947	try expect(v[12] == 541);
	14948	try expect(v[13] == 542);
	14949	try expect(v[14] == 543);
	14950	try expect(v[15] == 544);
	14951	try expect(v[16] == 545);
	14952	try expect(v[17] == 546);
	14953	try expect(v[18] == 547);
	14954	try expect(v[19] == 548);
	14955	try expect(v[20] == 549);
	14956	try expect(v[21] == 550);
	14957	try expect(v[22] == 551);
	14958	try expect(v[23] == 552);
	14959	try expect(v[24] == 553);
	14960	try expect(v[25] == 554);
	14961	try expect(v[26] == 555);
	14962	try expect(v[27] == 556);
	14963	try expect(v[28] == 557);
	14964	try expect(v[29] == 558);
	14965	try expect(v[30] == 559);
	14966	try expect(v[31] == 560);
	14967	try expect(v[32] == 561);
	14968	try expect(v[33] == 562);
	14969	try expect(v[34] == 563);
	14970	try expect(v[35] == 564);
	14971	try expect(v[36] == 565);
	14972	try expect(v[37] == 566);
	14973	try expect(v[38] == 567);
	14974	try expect(v[39] == 568);
	14975	try expect(v[40] == 569);
	14976	try expect(v[41] == 570);
	14977	try expect(v[42] == 571);
	14978	try expect(v[43] == 572);
	14979	try expect(v[44] == 573);
	14980	try expect(v[45] == 574);
	14981	try expect(v[46] == 575);
	14982	try expect(v[47] == 576);
	14983	c_vector_48_f64(.{
	14984	577, 578, 579, 580, 581, 582, 583, 584, 585, 586, 587, 588, 589, 590, 591, 592,
	14985	593, 594, 595, 596, 597, 598, 599, 600, 601, 602, 603, 604, 605, 606, 607, 608,
	14986	609, 610, 611, 612, 613, 614, 615, 616, 617, 618, 619, 620, 621, 622, 623, 624,
	14987	}, 48);
	14988	c_test_vector_48_f64();
	14989	}
	14990
	14991	export fn zig_ret_vector_64_f64() @Vector(64, f64) {
	14992	return .{
	14993	625, 626, 627, 628, 629, 630, 631, 632, 633, 634, 635, 636, 637, 638, 639, 640,
	14994	641, 642, 643, 644, 645, 646, 647, 648, 649, 650, 651, 652, 653, 654, 655, 656,
	14995	657, 658, 659, 660, 661, 662, 663, 664, 665, 666, 667, 668, 669, 670, 671, 672,
	14996	673, 674, 675, 676, 677, 678, 679, 680, 681, 682, 683, 684, 685, 686, 687, 688,
	14997	};
	14998	}
	14999	export fn zig_vector_64_f64(v: @Vector(64, f64), i: usize) void {
	15000	expect(v[0] == 689) catch @panic("test failure");
	15001	expect(v[1] == 690) catch @panic("test failure");
	15002	expect(v[2] == 691) catch @panic("test failure");
	15003	expect(v[3] == 692) catch @panic("test failure");
	15004	expect(v[4] == 693) catch @panic("test failure");
	15005	expect(v[5] == 694) catch @panic("test failure");
	15006	expect(v[6] == 695) catch @panic("test failure");
	15007	expect(v[7] == 696) catch @panic("test failure");
	15008	expect(v[8] == 697) catch @panic("test failure");
	15009	expect(v[9] == 698) catch @panic("test failure");
	15010	expect(v[10] == 699) catch @panic("test failure");
	15011	expect(v[11] == 700) catch @panic("test failure");
	15012	expect(v[12] == 701) catch @panic("test failure");
	15013	expect(v[13] == 702) catch @panic("test failure");
	15014	expect(v[14] == 703) catch @panic("test failure");
	15015	expect(v[15] == 704) catch @panic("test failure");
	15016	expect(v[16] == 705) catch @panic("test failure");
	15017	expect(v[17] == 706) catch @panic("test failure");
	15018	expect(v[18] == 707) catch @panic("test failure");
	15019	expect(v[19] == 708) catch @panic("test failure");
	15020	expect(v[20] == 709) catch @panic("test failure");
	15021	expect(v[21] == 710) catch @panic("test failure");
	15022	expect(v[22] == 711) catch @panic("test failure");
	15023	expect(v[23] == 712) catch @panic("test failure");
	15024	expect(v[24] == 713) catch @panic("test failure");
	15025	expect(v[25] == 714) catch @panic("test failure");
	15026	expect(v[26] == 715) catch @panic("test failure");
	15027	expect(v[27] == 716) catch @panic("test failure");
	15028	expect(v[28] == 717) catch @panic("test failure");
	15029	expect(v[29] == 718) catch @panic("test failure");
	15030	expect(v[30] == 719) catch @panic("test failure");
	15031	expect(v[31] == 720) catch @panic("test failure");
	15032	expect(v[32] == 721) catch @panic("test failure");
	15033	expect(v[33] == 722) catch @panic("test failure");
	15034	expect(v[34] == 723) catch @panic("test failure");
	15035	expect(v[35] == 724) catch @panic("test failure");
	15036	expect(v[36] == 725) catch @panic("test failure");
	15037	expect(v[37] == 726) catch @panic("test failure");
	15038	expect(v[38] == 727) catch @panic("test failure");
	15039	expect(v[39] == 728) catch @panic("test failure");
	15040	expect(v[40] == 729) catch @panic("test failure");
	15041	expect(v[41] == 730) catch @panic("test failure");
	15042	expect(v[42] == 731) catch @panic("test failure");
	15043	expect(v[43] == 732) catch @panic("test failure");
	15044	expect(v[44] == 733) catch @panic("test failure");
	15045	expect(v[45] == 734) catch @panic("test failure");
	15046	expect(v[46] == 735) catch @panic("test failure");
	15047	expect(v[47] == 736) catch @panic("test failure");
	15048	expect(v[48] == 737) catch @panic("test failure");
	15049	expect(v[49] == 738) catch @panic("test failure");
	15050	expect(v[50] == 739) catch @panic("test failure");
	15051	expect(v[51] == 740) catch @panic("test failure");
	15052	expect(v[52] == 741) catch @panic("test failure");
	15053	expect(v[53] == 742) catch @panic("test failure");
	15054	expect(v[54] == 743) catch @panic("test failure");
	15055	expect(v[55] == 744) catch @panic("test failure");
	15056	expect(v[56] == 745) catch @panic("test failure");
	15057	expect(v[57] == 746) catch @panic("test failure");
	15058	expect(v[58] == 747) catch @panic("test failure");
	15059	expect(v[59] == 748) catch @panic("test failure");
	15060	expect(v[60] == 749) catch @panic("test failure");
	15061	expect(v[61] == 750) catch @panic("test failure");
	15062	expect(v[62] == 751) catch @panic("test failure");
	15063	expect(v[63] == 752) catch @panic("test failure");
	15064	expect(i == 64) catch @panic("test failure");
	15065	}
	15066
	15067	extern fn c_ret_vector_64_f64() @Vector(64, f64);
	15068	extern fn c_vector_64_f64(@Vector(64, f64), usize) void;
	15069	extern fn c_test_vector_64_f64() void;
	15070
	15071	test "@Vector(64, f64)" {
	15072	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	15073	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15074	if (builtin.cpu.arch.isMIPS32()) return error.SkipZigTest;
	15075	if (builtin.cpu.arch.isPowerPC64()) return error.SkipZigTest;
	15076	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15077
	15078	const v = c_ret_vector_64_f64();
	15079	try expect(v[0] == 753);
	15080	try expect(v[1] == 754);
	15081	try expect(v[2] == 755);
	15082	try expect(v[3] == 756);
	15083	try expect(v[4] == 757);
	15084	try expect(v[5] == 758);
	15085	try expect(v[6] == 759);
	15086	try expect(v[7] == 760);
	15087	try expect(v[8] == 761);
	15088	try expect(v[9] == 762);
	15089	try expect(v[10] == 763);
	15090	try expect(v[11] == 764);
	15091	try expect(v[12] == 765);
	15092	try expect(v[13] == 766);
	15093	try expect(v[14] == 767);
	15094	try expect(v[15] == 768);
	15095	try expect(v[16] == 769);
	15096	try expect(v[17] == 770);
	15097	try expect(v[18] == 771);
	15098	try expect(v[19] == 772);
	15099	try expect(v[20] == 773);
	15100	try expect(v[21] == 774);
	15101	try expect(v[22] == 775);
	15102	try expect(v[23] == 776);
	15103	try expect(v[24] == 777);
	15104	try expect(v[25] == 778);
	15105	try expect(v[26] == 779);
	15106	try expect(v[27] == 780);
	15107	try expect(v[28] == 781);
	15108	try expect(v[29] == 782);
	15109	try expect(v[30] == 783);
	15110	try expect(v[31] == 784);
	15111	try expect(v[32] == 785);
	15112	try expect(v[33] == 786);
	15113	try expect(v[34] == 787);
	15114	try expect(v[35] == 788);
	15115	try expect(v[36] == 789);
	15116	try expect(v[37] == 790);
	15117	try expect(v[38] == 791);
	15118	try expect(v[39] == 792);
	15119	try expect(v[40] == 793);
	15120	try expect(v[41] == 794);
	15121	try expect(v[42] == 795);
	15122	try expect(v[43] == 796);
	15123	try expect(v[44] == 797);
	15124	try expect(v[45] == 798);
	15125	try expect(v[46] == 799);
	15126	try expect(v[47] == 800);
	15127	try expect(v[48] == 801);
	15128	try expect(v[49] == 802);
	15129	try expect(v[50] == 803);
	15130	try expect(v[51] == 804);
	15131	try expect(v[52] == 805);
	15132	try expect(v[53] == 806);
	15133	try expect(v[54] == 807);
	15134	try expect(v[55] == 808);
	15135	try expect(v[56] == 809);
	15136	try expect(v[57] == 810);
	15137	try expect(v[58] == 811);
	15138	try expect(v[59] == 812);
	15139	try expect(v[60] == 813);
	15140	try expect(v[61] == 814);
	15141	try expect(v[62] == 815);
	15142	try expect(v[63] == 816);
	15143	c_vector_64_f64(.{
	15144	817, 818, 819, 820, 821, 822, 823, 824, 825, 826, 827, 828, 829, 830, 831, 832,
	15145	833, 834, 835, 836, 837, 838, 839, 840, 841, 842, 843, 844, 845, 846, 847, 848,
	15146	849, 850, 851, 852, 853, 854, 855, 856, 857, 858, 859, 860, 861, 862, 863, 864,
	15147	865, 866, 867, 868, 869, 870, 871, 872, 873, 874, 875, 876, 877, 878, 879, 880,
	15148	}, 64);
	15149	c_test_vector_64_f64();
	15150	}
	15151
	15152	const Struct_u8 = extern struct {
	15153	a: u8,
	15154	};
	15155
	15156	export fn zig_ret_struct_u8() Struct_u8 {
	15157	return .{ .a = 1 };
	15158	}
	15159	export fn zig_struct_u8(s: Struct_u8, i: usize) void {
	15160	expect(s.a == 2) catch @panic("test failure");
	15161	expect(i == 3) catch @panic("test failure");
	15162	}
	15163
	15164	extern fn c_ret_struct_u8() Struct_u8;
	15165	extern fn c_struct_u8(Struct_u8, usize) void;
	15166	extern fn c_test_struct_u8() void;
	15167
	15168	test "struct u8" {
	15169	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15170	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	15171	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15172	if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
	15173
	15174	const s = c_ret_struct_u8();
	15175	try expect(s.a == 4);
	15176	c_struct_u8(.{ .a = 5 }, 6);
	15177	c_test_struct_u8();
	15178	}
	15179
	15180	const Struct_u8_u8 = extern struct {
	15181	a: u8,
	15182	b: u8,
	15183	};
	15184
	15185	export fn zig_ret_struct_u8_u8() Struct_u8_u8 {
	15186	return .{ .a = 1, .b = 2 };
	15187	}
	15188	export fn zig_struct_u8_u8(s: Struct_u8_u8, i: usize) void {
	15189	expect(s.a == 3) catch @panic("test failure");
	15190	expect(s.b == 4) catch @panic("test failure");
	15191	expect(i == 5) catch @panic("test failure");
	15192	}
	15193
	15194	extern fn c_ret_struct_u8_u8() Struct_u8_u8;
	15195	extern fn c_struct_u8_u8(Struct_u8_u8, usize) void;
	15196	extern fn c_test_struct_u8_u8() void;
	15197
	15198	test "struct u8, u8" {
	15199	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15200	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15201	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15202	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15203	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15204	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	15205
	15206	const s = c_ret_struct_u8_u8();
	15207	try expect(s.a == 6);
	15208	try expect(s.b == 7);
	15209	c_struct_u8_u8(.{ .a = 8, .b = 9 }, 10);
	15210	c_test_struct_u8_u8();
	15211	}
	15212
	15213	const Struct_u8_u8_u8 = extern struct {
	15214	a: u8,
	15215	b: u8,
	15216	c: u8,
	15217	};
	15218
	15219	export fn zig_ret_struct_u8_u8_u8() Struct_u8_u8_u8 {
	15220	return .{ .a = 1, .b = 2, .c = 3 };
	15221	}
	15222	export fn zig_struct_u8_u8_u8(s: Struct_u8_u8_u8, i: usize) void {
	15223	expect(s.a == 4) catch @panic("test failure");
	15224	expect(s.b == 5) catch @panic("test failure");
	15225	expect(s.c == 6) catch @panic("test failure");
	15226	expect(i == 7) catch @panic("test failure");
	15227	}
	15228
	15229	extern fn c_ret_struct_u8_u8_u8() Struct_u8_u8_u8;
	15230	extern fn c_struct_u8_u8_u8(Struct_u8_u8_u8, usize) void;
	15231	extern fn c_test_struct_u8_u8_u8() void;
	15232
	15233	test "struct u8, u8, u8" {
	15234	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15235	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15236	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15237	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15238	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15239	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	15240
	15241	const s = c_ret_struct_u8_u8_u8();
	15242	try expect(s.a == 8);
	15243	try expect(s.b == 9);
	15244	try expect(s.c == 10);
	15245	c_struct_u8_u8_u8(.{ .a = 11, .b = 12, .c = 13 }, 14);
	15246	c_test_struct_u8_u8_u8();
	15247	}
	15248
	15249	const Struct_u8_u8_u8_u8 = extern struct {
	15250	a: u8,
	15251	b: u8,
	15252	c: u8,
	15253	d: u8,
	15254	};
	15255
	15256	export fn zig_ret_struct_u8_u8_u8_u8() Struct_u8_u8_u8_u8 {
	15257	return .{ .a = 1, .b = 2, .c = 3, .d = 4 };
	15258	}
	15259	export fn zig_struct_u8_u8_u8_u8(s: Struct_u8_u8_u8_u8, i: usize) void {
	15260	expect(s.a == 5) catch @panic("test failure");
	15261	expect(s.b == 6) catch @panic("test failure");
	15262	expect(s.c == 7) catch @panic("test failure");
	15263	expect(s.d == 8) catch @panic("test failure");
	15264	expect(i == 9) catch @panic("test failure");
	15265	}
	15266
	15267	extern fn c_ret_struct_u8_u8_u8_u8() Struct_u8_u8_u8_u8;
	15268	extern fn c_struct_u8_u8_u8_u8(Struct_u8_u8_u8_u8, usize) void;
	15269	extern fn c_test_struct_u8_u8_u8_u8() void;
	15270
	15271	test "struct u8, u8, u8, u8" {
	15272	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15273	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15274	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15275	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15276	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15277	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	15278
	15279	const s = c_ret_struct_u8_u8_u8_u8();
	15280	try expect(s.a == 10);
	15281	try expect(s.b == 11);
	15282	try expect(s.c == 12);
	15283	try expect(s.d == 13);
	15284	c_struct_u8_u8_u8_u8(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18);
	15285	c_test_struct_u8_u8_u8_u8();
	15286	}
	15287
	15288	const Struct_u16 = extern struct {
	15289	a: u16,
	15290	};
	15291
	15292	export fn zig_ret_struct_u16() Struct_u16 {
	15293	return .{ .a = 1 };
	15294	}
	15295	export fn zig_struct_u16(s: Struct_u16, i: usize) void {
	15296	expect(s.a == 2) catch @panic("test failure");
	15297	expect(i == 3) catch @panic("test failure");
	15298	}
	15299
	15300	extern fn c_ret_struct_u16() Struct_u16;
	15301	extern fn c_struct_u16(Struct_u16, usize) void;
	15302	extern fn c_test_struct_u16() void;
	15303
	15304	test "struct u16" {
	15305	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15306	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	15307	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15308	if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
	15309
	15310	const s = c_ret_struct_u16();
	15311	try expect(s.a == 4);
	15312	c_struct_u16(.{ .a = 5 }, 6);
	15313	c_test_struct_u16();
	15314	}
	15315
	15316	const Struct_u16_u16 = extern struct {
	15317	a: u16,
	15318	b: u16,
	15319	};
	15320
	15321	export fn zig_ret_struct_u16_u16() Struct_u16_u16 {
	15322	return .{ .a = 1, .b = 2 };
	15323	}
	15324	export fn zig_struct_u16_u16(s: Struct_u16_u16, i: usize) void {
	15325	expect(s.a == 3) catch @panic("test failure");
	15326	expect(s.b == 4) catch @panic("test failure");
	15327	expect(i == 5) catch @panic("test failure");
	15328	}
	15329
	15330	extern fn c_ret_struct_u16_u16() Struct_u16_u16;
	15331	extern fn c_struct_u16_u16(Struct_u16_u16, usize) void;
	15332	extern fn c_test_struct_u16_u16() void;
	15333
	15334	test "struct u16, u16" {
	15335	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15336	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15337	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15338	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15339	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15340	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	15341
	15342	const s = c_ret_struct_u16_u16();
	15343	try expect(s.a == 6);
	15344	try expect(s.b == 7);
	15345	c_struct_u16_u16(.{ .a = 8, .b = 9 }, 10);
	15346	c_test_struct_u16_u16();
	15347	}
	15348
	15349	const Struct_u16_u16_u16 = extern struct {
	15350	a: u16,
	15351	b: u16,
	15352	c: u16,
	15353	};
	15354
	15355	export fn zig_ret_struct_u16_u16_u16() Struct_u16_u16_u16 {
	15356	return .{ .a = 1, .b = 2, .c = 3 };
	15357	}
	15358	export fn zig_struct_u16_u16_u16(s: Struct_u16_u16_u16, i: usize) void {
	15359	expect(s.a == 4) catch @panic("test failure");
	15360	expect(s.b == 5) catch @panic("test failure");
	15361	expect(s.c == 6) catch @panic("test failure");
	15362	expect(i == 7) catch @panic("test failure");
	15363	}
	15364
	15365	extern fn c_ret_struct_u16_u16_u16() Struct_u16_u16_u16;
	15366	extern fn c_struct_u16_u16_u16(Struct_u16_u16_u16, usize) void;
	15367	extern fn c_test_struct_u16_u16_u16() void;
	15368
	15369	test "struct u16, u16, u16" {
	15370	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15371	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15372	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15373	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15374	if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
	15375	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15376	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	15377
	15378	const s = c_ret_struct_u16_u16_u16();
	15379	try expect(s.a == 8);
	15380	try expect(s.b == 9);
	15381	try expect(s.c == 10);
	15382	c_struct_u16_u16_u16(.{ .a = 11, .b = 12, .c = 13 }, 14);
	15383	c_test_struct_u16_u16_u16();
	15384	}
	15385
	15386	const Struct_u16_u16_u16_u16 = extern struct {
	15387	a: u16,
	15388	b: u16,
	15389	c: u16,
	15390	d: u16,
	15391	};
	15392
	15393	export fn zig_ret_struct_u16_u16_u16_u16() Struct_u16_u16_u16_u16 {
	15394	return .{ .a = 1, .b = 2, .c = 3, .d = 4 };
	15395	}
	15396	export fn zig_struct_u16_u16_u16_u16(s: Struct_u16_u16_u16_u16, i: usize) void {
	15397	expect(s.a == 5) catch @panic("test failure");
	15398	expect(s.b == 6) catch @panic("test failure");
	15399	expect(s.c == 7) catch @panic("test failure");
	15400	expect(s.d == 8) catch @panic("test failure");
	15401	expect(i == 9) catch @panic("test failure");
	15402	}
	15403
	15404	extern fn c_ret_struct_u16_u16_u16_u16() Struct_u16_u16_u16_u16;
	15405	extern fn c_struct_u16_u16_u16_u16(Struct_u16_u16_u16_u16, usize) void;
	15406	extern fn c_test_struct_u16_u16_u16_u16() void;
	15407
	15408	test "struct u16, u16, u16, u16" {
	15409	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15410	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15411	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15412	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15413	if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
	15414	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15415	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	15416
	15417	const s = c_ret_struct_u16_u16_u16_u16();
	15418	try expect(s.a == 10);
	15419	try expect(s.b == 11);
	15420	try expect(s.c == 12);
	15421	try expect(s.d == 13);
	15422	c_struct_u16_u16_u16_u16(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18);
	15423	c_test_struct_u16_u16_u16_u16();
	15424	}
	15425
	15426	const Struct_u32 = extern struct {
	15427	a: u32,
	15428	};
	15429
	15430	export fn zig_ret_struct_u32() Struct_u32 {
	15431	return .{ .a = 1 };
	15432	}
	15433	export fn zig_struct_u32(s: Struct_u32, i: usize) void {
	15434	expect(s.a == 2) catch @panic("test failure");
	15435	expect(i == 3) catch @panic("test failure");
	15436	}
	15437
	15438	extern fn c_ret_struct_u32() Struct_u32;
	15439	extern fn c_struct_u32(Struct_u32, usize) void;
	15440	extern fn c_test_struct_u32() void;
	15441
	15442	test "struct u32" {
	15443	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15444	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	15445	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15446	if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
	15447
	15448	const s = c_ret_struct_u32();
	15449	try expect(s.a == 4);
	15450	c_struct_u32(.{ .a = 5 }, 6);
	15451	c_test_struct_u32();
	15452	}
	15453
	15454	const Struct_u32_u32 = extern struct {
	15455	a: u32,
	15456	b: u32,
	15457	};
	15458
	15459	export fn zig_ret_struct_u32_u32() Struct_u32_u32 {
	15460	return .{ .a = 1, .b = 2 };
	15461	}
	15462	export fn zig_struct_u32_u32(s: Struct_u32_u32, i: usize) void {
	15463	expect(s.a == 3) catch @panic("test failure");
	15464	expect(s.b == 4) catch @panic("test failure");
	15465	expect(i == 5) catch @panic("test failure");
	15466	}
	15467
	15468	extern fn c_ret_struct_u32_u32() Struct_u32_u32;
	15469	extern fn c_struct_u32_u32(Struct_u32_u32, usize) void;
	15470	extern fn c_test_struct_u32_u32() void;
	15471
	15472	test "struct u32, u32" {
	15473	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15474	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15475	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15476	if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
	15477	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15478	if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
	15479
	15480	const s = c_ret_struct_u32_u32();
	15481	try expect(s.a == 6);
	15482	try expect(s.b == 7);
	15483	c_struct_u32_u32(.{ .a = 8, .b = 9 }, 10);
	15484	c_test_struct_u32_u32();
	15485	}
	15486
	15487	const Struct_u32_u32_u32 = extern struct {
	15488	a: u32,
	15489	b: u32,
	15490	c: u32,
	15491	};
	15492
	15493	export fn zig_ret_struct_u32_u32_u32() Struct_u32_u32_u32 {
	15494	return .{ .a = 1, .b = 2, .c = 3 };
	15495	}
	15496	export fn zig_struct_u32_u32_u32(s: Struct_u32_u32_u32, i: usize) void {
	15497	expect(s.a == 4) catch @panic("test failure");
	15498	expect(s.b == 5) catch @panic("test failure");
	15499	expect(s.c == 6) catch @panic("test failure");
	15500	expect(i == 7) catch @panic("test failure");
	15501	}
	15502
	15503	extern fn c_ret_struct_u32_u32_u32() Struct_u32_u32_u32;
	15504	extern fn c_struct_u32_u32_u32(Struct_u32_u32_u32, usize) void;
	15505	extern fn c_test_struct_u32_u32_u32() void;
	15506
	15507	test "struct u32, u32, u32" {
	15508	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15509	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15510	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15511	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15512	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15513
	15514	const s = c_ret_struct_u32_u32_u32();
	15515	try expect(s.a == 8);
	15516	try expect(s.b == 9);
	15517	try expect(s.c == 10);
	15518	c_struct_u32_u32_u32(.{ .a = 11, .b = 12, .c = 13 }, 14);
	15519	c_test_struct_u32_u32_u32();
	15520	}
	15521
	15522	const Struct_u32_u32_u32_u32 = extern struct {
	15523	a: u32,
	15524	b: u32,
	15525	c: u32,
	15526	d: u32,
	15527	};
	15528
	15529	export fn zig_ret_struct_u32_u32_u32_u32() Struct_u32_u32_u32_u32 {
	15530	return .{ .a = 1, .b = 2, .c = 3, .d = 4 };
	15531	}
	15532	export fn zig_struct_u32_u32_u32_u32(s: Struct_u32_u32_u32_u32, i: usize) void {
	15533	expect(s.a == 5) catch @panic("test failure");
	15534	expect(s.b == 6) catch @panic("test failure");
	15535	expect(s.c == 7) catch @panic("test failure");
	15536	expect(s.d == 8) catch @panic("test failure");
	15537	expect(i == 9) catch @panic("test failure");
	15538	}
	15539
	15540	extern fn c_ret_struct_u32_u32_u32_u32() Struct_u32_u32_u32_u32;
	15541	extern fn c_struct_u32_u32_u32_u32(Struct_u32_u32_u32_u32, usize) void;
	15542	extern fn c_test_struct_u32_u32_u32_u32() void;
	15543
	15544	test "struct u32, u32, u32, u32" {
	15545	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15546	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15547	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15548	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15549	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15550
	15551	const s = c_ret_struct_u32_u32_u32_u32();
	15552	try expect(s.a == 10);
	15553	try expect(s.b == 11);
	15554	try expect(s.c == 12);
	15555	try expect(s.d == 13);
	15556	c_struct_u32_u32_u32_u32(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18);
	15557	c_test_struct_u32_u32_u32_u32();
	15558	}
	15559
	15560	const Struct_u64 = extern struct {
	15561	a: u64,
	15562	};
	15563
	15564	export fn zig_ret_struct_u64() Struct_u64 {
	15565	return .{ .a = 1 };
	15566	}
	15567	export fn zig_struct_u64(s: Struct_u64, i: usize) void {
	15568	expect(s.a == 2) catch @panic("test failure");
	15569	expect(i == 3) catch @panic("test failure");
	15570	}
	15571
	15572	extern fn c_ret_struct_u64() Struct_u64;
	15573	extern fn c_struct_u64(Struct_u64, usize) void;
	15574	extern fn c_test_struct_u64() void;
	15575
	15576	test "struct u64" {
	15577	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	15578	if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
	15579	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15580	if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
	15581
	15582	const s = c_ret_struct_u64();
	15583	try expect(s.a == 4);
	15584	c_struct_u64(.{ .a = 5 }, 6);
	15585	c_test_struct_u64();
	15586	}
	15587
	15588	const Struct_u64_u64 = extern struct {
	15589	a: u64,
	15590	b: u64,
	15591	};
	15592
	15593	export fn zig_ret_struct_u64_u64() Struct_u64_u64 {
	15594	return .{ .a = 1, .b = 2 };
	15595	}
	15596	export fn zig_struct_u64_u64(s: Struct_u64_u64, i: usize) void {
	15597	expect(s.a == 3) catch @panic("test failure");
	15598	expect(s.b == 4) catch @panic("test failure");
	15599	expect(i == 1) catch @panic("test failure");
	15600	}
	15601	export fn zig_1_struct_u64_u64(_: usize, s: Struct_u64_u64, i: usize) void {
	15602	expect(s.a == 5) catch @panic("test failure");
	15603	expect(s.b == 6) catch @panic("test failure");
	15604	expect(i == 2) catch @panic("test failure");
	15605	}
	15606	export fn zig_2_struct_u64_u64(_: usize, _: usize, s: Struct_u64_u64, i: usize) void {
	15607	expect(s.a == 7) catch @panic("test failure");
	15608	expect(s.b == 8) catch @panic("test failure");
	15609	expect(i == 3) catch @panic("test failure");
	15610	}
	15611	export fn zig_3_struct_u64_u64(_: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
	15612	expect(s.a == 9) catch @panic("test failure");
	15613	expect(s.b == 10) catch @panic("test failure");
	15614	expect(i == 4) catch @panic("test failure");
	15615	}
	15616	export fn zig_4_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
	15617	expect(s.a == 11) catch @panic("test failure");
	15618	expect(s.b == 12) catch @panic("test failure");
	15619	expect(i == 5) catch @panic("test failure");
	15620	}
	15621	export fn zig_5_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
	15622	expect(s.a == 13) catch @panic("test failure");
	15623	expect(s.b == 14) catch @panic("test failure");
	15624	expect(i == 6) catch @panic("test failure");
	15625	}
	15626	export fn zig_6_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
	15627	expect(s.a == 15) catch @panic("test failure");
	15628	expect(s.b == 16) catch @panic("test failure");
	15629	expect(i == 7) catch @panic("test failure");
	15630	}
	15631	export fn zig_7_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
	15632	expect(s.a == 17) catch @panic("test failure");
	15633	expect(s.b == 18) catch @panic("test failure");
	15634	expect(i == 8) catch @panic("test failure");
	15635	}
	15636	export fn zig_8_struct_u64_u64(_: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, _: usize, s: Struct_u64_u64, i: usize) void {
	15637	expect(s.a == 19) catch @panic("test failure");
	15638	expect(s.b == 20) catch @panic("test failure");
	15639	expect(i == 9) catch @panic("test failure");
	15640	}
	15641
	15642	extern fn c_ret_struct_u64_u64() Struct_u64_u64;
	15643	extern fn c_struct_u64_u64(Struct_u64_u64, usize) void;
	15644	extern fn c_1_struct_u64_u64(usize, Struct_u64_u64, usize) void;
	15645	extern fn c_2_struct_u64_u64(usize, usize, Struct_u64_u64, usize) void;
	15646	extern fn c_3_struct_u64_u64(usize, usize, usize, Struct_u64_u64, usize) void;
	15647	extern fn c_4_struct_u64_u64(usize, usize, usize, usize, Struct_u64_u64, usize) void;
	15648	extern fn c_5_struct_u64_u64(usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
	15649	extern fn c_6_struct_u64_u64(usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
	15650	extern fn c_7_struct_u64_u64(usize, usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
	15651	extern fn c_8_struct_u64_u64(usize, usize, usize, usize, usize, usize, usize, usize, Struct_u64_u64, usize) void;
	15652	extern fn c_test_struct_u64_u64() void;
	15653
	15654	test "struct u64, u64" {
	15655	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15656	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	15657	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15658
	15659	const s = c_ret_struct_u64_u64();
	15660	try expect(s.a == 21);
	15661	try expect(s.b == 22);
	15662	c_struct_u64_u64(.{ .a = 23, .b = 24 }, 1);
	15663	c_1_struct_u64_u64(0, .{ .a = 25, .b = 26 }, 2);
	15664	c_2_struct_u64_u64(0, 1, .{ .a = 27, .b = 28 }, 3);
	15665	c_3_struct_u64_u64(0, 1, 2, .{ .a = 29, .b = 30 }, 4);
	15666	c_4_struct_u64_u64(0, 1, 2, 3, .{ .a = 31, .b = 32 }, 5);
	15667	c_5_struct_u64_u64(0, 1, 2, 3, 4, .{ .a = 33, .b = 34 }, 6);
	15668	c_6_struct_u64_u64(0, 1, 2, 3, 4, 5, .{ .a = 35, .b = 36 }, 7);
	15669	c_7_struct_u64_u64(0, 1, 2, 3, 4, 5, 6, .{ .a = 37, .b = 38 }, 8);
	15670	c_8_struct_u64_u64(0, 1, 2, 3, 4, 5, 6, 7, .{ .a = 39, .b = 40 }, 9);
	15671	c_test_struct_u64_u64();
	15672	}
	15673
	15674	const Struct_u64_u64_u64 = extern struct {
	15675	a: u64,
	15676	b: u64,
	15677	c: u64,
	15678	};
	15679
	15680	export fn zig_ret_struct_u64_u64_u64() Struct_u64_u64_u64 {
	15681	return .{ .a = 1, .b = 2, .c = 3 };
	15682	}
	15683	export fn zig_struct_u64_u64_u64(s: Struct_u64_u64_u64, i: usize) void {
	15684	expect(s.a == 4) catch @panic("test failure");
	15685	expect(s.b == 5) catch @panic("test failure");
	15686	expect(s.c == 6) catch @panic("test failure");
	15687	expect(i == 7) catch @panic("test failure");
	15688	}
	15689
	15690	extern fn c_ret_struct_u64_u64_u64() Struct_u64_u64_u64;
	15691	extern fn c_struct_u64_u64_u64(Struct_u64_u64_u64, usize) void;
	15692	extern fn c_test_struct_u64_u64_u64() void;
	15693
	15694	test "struct u64, u64, u64" {
	15695	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15696	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15697	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15698	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15699
	15700	const s = c_ret_struct_u64_u64_u64();
	15701	try expect(s.a == 8);
	15702	try expect(s.b == 9);
	15703	try expect(s.c == 10);
	15704	c_struct_u64_u64_u64(.{ .a = 11, .b = 12, .c = 13 }, 14);
	15705	c_test_struct_u64_u64_u64();
	15706	}
	15707
	15708	const Struct_u64_u64_u64_u64 = extern struct {
	15709	a: u64,
	15710	b: u64,
	15711	c: u64,
	15712	d: u64,
	15713	};
	15714
	15715	export fn zig_ret_struct_u64_u64_u64_u64() Struct_u64_u64_u64_u64 {
	15716	return .{ .a = 1, .b = 2, .c = 3, .d = 4 };
	15717	}
	15718	export fn zig_struct_u64_u64_u64_u64(s: Struct_u64_u64_u64_u64, i: usize) void {
	15719	expect(s.a == 5) catch @panic("test failure");
	15720	expect(s.b == 6) catch @panic("test failure");
	15721	expect(s.c == 7) catch @panic("test failure");
	15722	expect(s.d == 8) catch @panic("test failure");
	15723	expect(i == 9) catch @panic("test failure");
	15724	}
	15725
	15726	extern fn c_ret_struct_u64_u64_u64_u64() Struct_u64_u64_u64_u64;
	15727	extern fn c_struct_u64_u64_u64_u64(Struct_u64_u64_u64_u64, usize) void;
	15728	extern fn c_test_struct_u64_u64_u64_u64() void;
	15729
	15730	test "struct u64, u64, u64, u64" {
	15731	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15732	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15733	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15734	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15735
	15736	const s = c_ret_struct_u64_u64_u64_u64();
	15737	try expect(s.a == 10);
	15738	try expect(s.b == 11);
	15739	try expect(s.c == 12);
	15740	try expect(s.d == 13);
	15741	c_struct_u64_u64_u64_u64(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18);
	15742	c_test_struct_u64_u64_u64_u64();
	15743	}
	15744
	15745	const Struct_f32 = extern struct {
	15746	a: f32,
	15747	};
	15748
	15749	export fn zig_ret_struct_f32() Struct_f32 {
	15750	return .{ .a = 1 };
	15751	}
	15752	export fn zig_struct_f32(s: Struct_f32, i: usize) void {
	15753	expect(s.a == 2) catch @panic("test failure");
	15754	expect(i == 3) catch @panic("test failure");
	15755	}
	15756
	15757	extern fn c_ret_struct_f32() Struct_f32;
	15758	extern fn c_struct_f32(Struct_f32, usize) void;
	15759	extern fn c_test_struct_f32() void;
	15760
	15761	test "struct f32" {
	15762	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15763	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	15764	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15765	if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
	15766
	15767	const s = c_ret_struct_f32();
	15768	try expect(s.a == 4);
	15769	c_struct_f32(.{ .a = 5 }, 6);
	15770	c_test_struct_f32();
	15771	}
	15772
	15773	const Struct_f32_f32 = extern struct {
	15774	a: f32,
	15775	b: f32,
	15776	};
	15777
	15778	export fn zig_ret_struct_f32_f32() Struct_f32_f32 {
	15779	return .{ .a = 1, .b = 2 };
	15780	}
	15781	export fn zig_struct_f32_f32(s: Struct_f32_f32, i: usize) void {
	15782	expect(s.a == 3) catch @panic("test failure");
	15783	expect(s.b == 4) catch @panic("test failure");
	15784	expect(i == 5) catch @panic("test failure");
	15785	}
	15786
	15787	extern fn c_ret_struct_f32_f32() Struct_f32_f32;
	15788	extern fn c_struct_f32_f32(Struct_f32_f32, usize) void;
	15789	extern fn c_test_struct_f32_f32() void;
	15790
	15791	test "struct f32, f32" {
	15792	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	15793	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15794	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15795	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15796	if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
	15797	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15798	if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
	15799
	15800	const s = c_ret_struct_f32_f32();
	15801	try expect(s.a == 6);
	15802	try expect(s.b == 7);
	15803	c_struct_f32_f32(.{ .a = 8, .b = 9 }, 10);
	15804	c_test_struct_f32_f32();
	15805	}
	15806
	15807	const Struct_f32_f32_f32 = extern struct {
	15808	a: f32,
	15809	b: f32,
	15810	c: f32,
	15811	};
	15812
	15813	export fn zig_ret_struct_f32_f32_f32() Struct_f32_f32_f32 {
	15814	return .{ .a = 1, .b = 2, .c = 3 };
	15815	}
	15816	export fn zig_struct_f32_f32_f32(s: Struct_f32_f32_f32, i: usize) void {
	15817	expect(s.a == 4) catch @panic("test failure");
	15818	expect(s.b == 5) catch @panic("test failure");
	15819	expect(s.c == 6) catch @panic("test failure");
	15820	expect(i == 7) catch @panic("test failure");
	15821	}
	15822
	15823	extern fn c_ret_struct_f32_f32_f32() Struct_f32_f32_f32;
	15824	extern fn c_struct_f32_f32_f32(Struct_f32_f32_f32, usize) void;
	15825	extern fn c_test_struct_f32_f32_f32() void;
	15826
	15827	test "struct f32, f32, f32" {
	15828	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	15829	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15830	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15831	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15832	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15833	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15834
	15835	const s = c_ret_struct_f32_f32_f32();
	15836	try expect(s.a == 8);
	15837	try expect(s.b == 9);
	15838	try expect(s.c == 10);
	15839	c_struct_f32_f32_f32(.{ .a = 11, .b = 12, .c = 13 }, 14);
	15840	c_test_struct_f32_f32_f32();
	15841	}
	15842
	15843	const Struct_f32_f32_f32_f32 = extern struct {
	15844	a: f32,
	15845	b: f32,
	15846	c: f32,
	15847	d: f32,
	15848	};
	15849
	15850	export fn zig_ret_struct_f32_f32_f32_f32() Struct_f32_f32_f32_f32 {
	15851	return .{ .a = 1, .b = 2, .c = 3, .d = 4 };
	15852	}
	15853	export fn zig_struct_f32_f32_f32_f32(s: Struct_f32_f32_f32_f32, i: usize) void {
	15854	expect(s.a == 5) catch @panic("test failure");
	15855	expect(s.b == 6) catch @panic("test failure");
	15856	expect(s.c == 7) catch @panic("test failure");
	15857	expect(s.d == 8) catch @panic("test failure");
	15858	expect(i == 9) catch @panic("test failure");
	15859	}
	15860
	15861	extern fn c_ret_struct_f32_f32_f32_f32() Struct_f32_f32_f32_f32;
	15862	extern fn c_struct_f32_f32_f32_f32(Struct_f32_f32_f32_f32, usize) void;
	15863	extern fn c_test_struct_f32_f32_f32_f32() void;
	15864
	15865	test "struct f32, f32, f32, f32" {
	15866	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	15867	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15868	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15869	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15870	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15871	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15872
	15873	const s = c_ret_struct_f32_f32_f32_f32();
	15874	try expect(s.a == 10);
	15875	try expect(s.b == 11);
	15876	try expect(s.c == 12);
	15877	try expect(s.d == 13);
	15878	c_struct_f32_f32_f32_f32(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18);
	15879	c_test_struct_f32_f32_f32_f32();
	15880	}
	15881
	15882	const Struct_f32_f32_f32_f32_f32 = extern struct {
	15883	a: f32,
	15884	b: f32,
	15885	c: f32,
	15886	d: f32,
	15887	e: f32,
	15888	};
	15889
	15890	export fn zig_ret_struct_f32_f32_f32_f32_f32() Struct_f32_f32_f32_f32_f32 {
	15891	return .{ .a = 1, .b = 2, .c = 3, .d = 4, .e = 5 };
	15892	}
	15893	export fn zig_struct_f32_f32_f32_f32_f32(s: Struct_f32_f32_f32_f32_f32, i: usize) void {
	15894	expect(s.a == 6) catch @panic("test failure");
	15895	expect(s.b == 7) catch @panic("test failure");
	15896	expect(s.c == 8) catch @panic("test failure");
	15897	expect(s.d == 9) catch @panic("test failure");
	15898	expect(s.e == 10) catch @panic("test failure");
	15899	expect(i == 11) catch @panic("test failure");
	15900	}
	15901
	15902	extern fn c_ret_struct_f32_f32_f32_f32_f32() Struct_f32_f32_f32_f32_f32;
	15903	extern fn c_struct_f32_f32_f32_f32_f32(Struct_f32_f32_f32_f32_f32, usize) void;
	15904	extern fn c_test_struct_f32_f32_f32_f32_f32() void;
	15905
	15906	test "struct f32, f32, f32, f32, f32" {
	15907	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15908	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15909	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15910	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15911	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15912
	15913	const s = c_ret_struct_f32_f32_f32_f32_f32();
	15914	try expect(s.a == 12);
	15915	try expect(s.b == 13);
	15916	try expect(s.c == 14);
	15917	try expect(s.d == 15);
	15918	try expect(s.e == 16);
	15919	c_struct_f32_f32_f32_f32_f32(.{ .a = 17, .b = 18, .c = 19, .d = 20, .e = 21 }, 22);
	15920	c_test_struct_f32_f32_f32_f32_f32();
	15921	}
	15922
	15923	const Struct_f32a8 = extern struct {
	15924	a: f32 align(8),
	15925	};
	15926
	15927	export fn zig_ret_struct_f32a8() Struct_f32a8 {
	15928	return .{ .a = 1.25 };
	15929	}
	15930	export fn zig_struct_f32a8(s: Struct_f32a8, f: f32) void {
	15931	expect(s.a == 2.75) catch @panic("test failure");
	15932	expect(f == 3.5) catch @panic("test failure");
	15933	}
	15934
	15935	extern fn c_ret_struct_f32a8() Struct_f32a8;
	15936	extern fn c_struct_f32a8(Struct_f32a8, f32) void;
	15937	extern fn c_test_struct_f32a8() void;
	15938
	15939	test "struct f32 align(8)" {
	15940	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	15941	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15942	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15943	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15944	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15945	if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
	15946	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15947	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	15948
	15949	const s = c_ret_struct_f32a8();
	15950	try expect(s.a == 4.125);
	15951	c_struct_f32a8(.{ .a = 5.375 }, 6.5);
	15952	c_test_struct_f32a8();
	15953	}
	15954
	15955	const Struct_f32a8_f32a8 = extern struct {
	15956	a: f32 align(8),
	15957	b: f32 align(8),
	15958	};
	15959
	15960	export fn zig_ret_struct_f32a8_f32a8() Struct_f32a8_f32a8 {
	15961	return .{ .a = 1.25, .b = 2.75 };
	15962	}
	15963	export fn zig_struct_f32a8_f32a8(s: Struct_f32a8_f32a8, f: f32) void {
	15964	expect(s.a == 3.125) catch @panic("test failure");
	15965	expect(s.b == 4.375) catch @panic("test failure");
	15966	expect(f == 5.5) catch @panic("test failure");
	15967	}
	15968
	15969	extern fn c_ret_struct_f32a8_f32a8() Struct_f32a8_f32a8;
	15970	extern fn c_struct_f32a8_f32a8(Struct_f32a8_f32a8, f32) void;
	15971	extern fn c_test_struct_f32a8_f32a8() void;
	15972
	15973	test "struct f32 align(8), f32 align(8)" {
	15974	if (builtin.cpu.arch.isArm()) return error.SkipZigTest;
	15975	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	15976	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	15977	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	15978	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	15979	if (builtin.cpu.arch.isRISCV()) return error.SkipZigTest;
	15980	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	15981	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	15982
	15983	const s = c_ret_struct_f32a8_f32a8();
	15984	try expect(s.a == 6.625);
	15985	try expect(s.b == 7.875);
	15986	c_struct_f32a8_f32a8(.{ .a = 8.0625, .b = 9.1875 }, 10.5);
	15987	c_test_struct_f32a8_f32a8();
	15988	}
	15989
	15990	const Struct_f32f32_f32 = extern struct {
	15991	a: extern struct { b: f32, c: f32 },
	15992	d: f32,
	15993	};
	15994
	15995	export fn zig_ret_struct_f32f32_f32() Struct_f32f32_f32 {
	15996	return .{ .a = .{ .b = 1.0, .c = 2.0 }, .d = 3.0 };
	15997	}
	15998	export fn zig_struct_f32f32_f32(s: Struct_f32f32_f32) void {
	15999	expect(s.a.b == 1.0) catch @panic("test failure");
	16000	expect(s.a.c == 2.0) catch @panic("test failure");
	16001	expect(s.d == 3.0) catch @panic("test failure");
	16002	}
	16003
	16004	extern fn c_ret_struct_f32f32_f32() Struct_f32f32_f32;
	16005	extern fn c_struct_f32f32_f32(Struct_f32f32_f32) void;
	16006	extern fn c_test_struct_f32f32_f32() void;
	16007
	16008	test "struct {f32, f32}, f32" {
	16009	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	16010	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16011	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	16012	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	16013	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	16014	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16015
	16016	const s = c_ret_struct_f32f32_f32();
	16017	try expect(s.a.b == 1.0);
	16018	try expect(s.a.c == 2.0);
	16019	try expect(s.d == 3.0);
	16020	c_struct_f32f32_f32(.{ .a = .{ .b = 1.0, .c = 2.0 }, .d = 3.0 });
	16021	c_test_struct_f32f32_f32();
	16022	}
	16023
	16024	const Struct_f32_f32f32 = extern struct {
	16025	a: f32,
	16026	b: extern struct { c: f32, d: f32 },
	16027	};
	16028
	16029	export fn zig_ret_struct_f32_f32f32() Struct_f32_f32f32 {
	16030	return .{ .a = 1.0, .b = .{ .c = 2.0, .d = 3.0 } };
	16031	}
	16032	export fn zig_struct_f32_f32f32(s: Struct_f32_f32f32) void {
	16033	expect(s.a == 1.0) catch @panic("test failure");
	16034	expect(s.b.c == 2.0) catch @panic("test failure");
	16035	expect(s.b.d == 3.0) catch @panic("test failure");
	16036	}
	16037
	16038	extern fn c_ret_struct_f32_f32f32() Struct_f32_f32f32;
	16039	extern fn c_struct_f32_f32f32(Struct_f32_f32f32) void;
	16040	extern fn c_test_struct_f32_f32f32() void;
	16041
	16042	test "struct f32, {f32, f32}" {
	16043	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	16044	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16045	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	16046	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	16047	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	16048	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16049
	16050	const s = c_ret_struct_f32_f32f32();
	16051	try expect(s.a == 1.0);
	16052	try expect(s.b.c == 2.0);
	16053	try expect(s.b.d == 3.0);
	16054	c_struct_f32_f32f32(.{ .a = 1.0, .b = .{ .c = 2.0, .d = 3.0 } });
	16055	c_test_struct_f32_f32f32();
	16056	}
	16057
	16058	const Struct_f64 = extern struct {
	16059	a: f64,
	16060	};
	16061
	16062	export fn zig_ret_struct_f64() Struct_f64 {
	16063	return .{ .a = 1 };
	16064	}
	16065	export fn zig_struct_f64(s: Struct_f64, i: usize) void {
	16066	expect(s.a == 2) catch @panic("test failure");
	16067	expect(i == 3) catch @panic("test failure");
	16068	}
	16069
	16070	extern fn c_ret_struct_f64() Struct_f64;
	16071	extern fn c_struct_f64(Struct_f64, usize) void;
	16072	extern fn c_test_struct_f64() void;
	16073
	16074	test "struct f64" {
	16075	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	16076	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	16077	if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
	16078	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16079	if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
	16080
	16081	const s = c_ret_struct_f64();
	16082	try expect(s.a == 4);
	16083	c_struct_f64(.{ .a = 5 }, 6);
	16084	c_test_struct_f64();
	16085	}
	16086
	16087	const Struct_f64_f64 = extern struct {
	16088	a: f64,
	16089	b: f64,
	16090	};
	16091
	16092	export fn zig_ret_struct_f64_f64() Struct_f64_f64 {
	16093	return .{ .a = 1, .b = 2 };
	16094	}
	16095	export fn zig_struct_f64_f64(s: Struct_f64_f64, i: usize) void {
	16096	expect(s.a == 3) catch @panic("test failure");
	16097	expect(s.b == 4) catch @panic("test failure");
	16098	expect(i == 5) catch @panic("test failure");
	16099	}
	16100
	16101	extern fn c_ret_struct_f64_f64() Struct_f64_f64;
	16102	extern fn c_struct_f64_f64(Struct_f64_f64, usize) void;
	16103	extern fn c_test_struct_f64_f64() void;
	16104
	16105	test "struct f64, f64" {
	16106	if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
	16107	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16108	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	16109	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16110
	16111	const s = c_ret_struct_f64_f64();
	16112	try expect(s.a == 6);
	16113	try expect(s.b == 7);
	16114	c_struct_f64_f64(.{ .a = 8, .b = 9 }, 10);
	16115	c_test_struct_f64_f64();
	16116	}
	16117
	16118	const Struct_f64_f64_f64 = extern struct {
	16119	a: f64,
	16120	b: f64,
	16121	c: f64,
	16122	};
	16123
	16124	export fn zig_ret_struct_f64_f64_f64() Struct_f64_f64_f64 {
	16125	return .{ .a = 1, .b = 2, .c = 3 };
	16126	}
	16127	export fn zig_struct_f64_f64_f64(s: Struct_f64_f64_f64, i: usize) void {
	16128	expect(s.a == 4) catch @panic("test failure");
	16129	expect(s.b == 5) catch @panic("test failure");
	16130	expect(s.c == 6) catch @panic("test failure");
	16131	expect(i == 7) catch @panic("test failure");
	16132	}
	16133
	16134	extern fn c_ret_struct_f64_f64_f64() Struct_f64_f64_f64;
	16135	extern fn c_struct_f64_f64_f64(Struct_f64_f64_f64, usize) void;
	16136	extern fn c_test_struct_f64_f64_f64() void;
	16137
	16138	test "struct f64, f64, f64" {
	16139	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16140	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	16141	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	16142	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16143
	16144	const s = c_ret_struct_f64_f64_f64();
	16145	try expect(s.a == 8);
	16146	try expect(s.b == 9);
	16147	try expect(s.c == 10);
	16148	c_struct_f64_f64_f64(.{ .a = 11, .b = 12, .c = 13 }, 14);
	16149	c_test_struct_f64_f64_f64();
	16150	}
	16151
	16152	const Struct_f64_f64_f64_f64 = extern struct {
	16153	a: f64,
	16154	b: f64,
	16155	c: f64,
	16156	d: f64,
	16157	};
	16158
	16159	export fn zig_ret_struct_f64_f64_f64_f64() Struct_f64_f64_f64_f64 {
	16160	return .{ .a = 1, .b = 2, .c = 3, .d = 4 };
	16161	}
	16162	export fn zig_struct_f64_f64_f64_f64(s: Struct_f64_f64_f64_f64, i: usize) void {
	16163	expect(s.a == 5) catch @panic("test failure");
	16164	expect(s.b == 6) catch @panic("test failure");
	16165	expect(s.c == 7) catch @panic("test failure");
	16166	expect(s.d == 8) catch @panic("test failure");
	16167	expect(i == 9) catch @panic("test failure");
	16168	}
	16169
	16170	extern fn c_ret_struct_f64_f64_f64_f64() Struct_f64_f64_f64_f64;
	16171	extern fn c_struct_f64_f64_f64_f64(Struct_f64_f64_f64_f64, usize) void;
	16172	extern fn c_test_struct_f64_f64_f64_f64() void;
	16173
	16174	test "struct f64, f64, f64, f64" {
	16175	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16176	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	16177	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	16178	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16179
	16180	const s = c_ret_struct_f64_f64_f64_f64();
	16181	try expect(s.a == 10);
	16182	try expect(s.b == 11);
	16183	try expect(s.c == 12);
	16184	try expect(s.d == 13);
	16185	c_struct_f64_f64_f64_f64(.{ .a = 14, .b = 15, .c = 16, .d = 17 }, 18);
	16186	c_test_struct_f64_f64_f64_f64();
	16187	}
	16188
	16189	const Struct_f64_f64_f64_f64_f64 = extern struct {
	16190	a: f64,
	16191	b: f64,
	16192	c: f64,
	16193	d: f64,
	16194	e: f64,
	16195	};
	16196
	16197	export fn zig_ret_struct_f64_f64_f64_f64_f64() Struct_f64_f64_f64_f64_f64 {
	16198	return .{ .a = 1, .b = 2, .c = 3, .d = 4, .e = 5 };
	16199	}
	16200	export fn zig_struct_f64_f64_f64_f64_f64(s: Struct_f64_f64_f64_f64_f64, i: usize) void {
	16201	expect(s.a == 6) catch @panic("test failure");
	16202	expect(s.b == 7) catch @panic("test failure");
	16203	expect(s.c == 8) catch @panic("test failure");
	16204	expect(s.d == 9) catch @panic("test failure");
	16205	expect(s.e == 10) catch @panic("test failure");
	16206	expect(i == 11) catch @panic("test failure");
	16207	}
	16208
	16209	extern fn c_ret_struct_f64_f64_f64_f64_f64() Struct_f64_f64_f64_f64_f64;
	16210	extern fn c_struct_f64_f64_f64_f64_f64(Struct_f64_f64_f64_f64_f64, usize) void;
	16211	extern fn c_test_struct_f64_f64_f64_f64_f64() void;
	16212
	16213	test "struct f64, f64, f64, f64, f64" {
	16214	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16215	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	16216	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	16217	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16218
	16219	const s = c_ret_struct_f64_f64_f64_f64_f64();
	16220	try expect(s.a == 12);
	16221	try expect(s.b == 13);
	16222	try expect(s.c == 14);
	16223	try expect(s.d == 15);
	16224	try expect(s.e == 16);
	16225	c_struct_f64_f64_f64_f64_f64(.{ .a = 17, .b = 18, .c = 19, .d = 20, .e = 21 }, 22);
	16226	c_test_struct_f64_f64_f64_f64_f64();
	16227	}
	16228
	16229	const Struct_u32_Union_u32_u32u32 = extern struct {
	16230	a: u32,
	16231	b: extern union {
	16232	c: extern struct {
	16233	d: u32,
	16234	e: u32,
	16235	},
	16236	},
	16237	};
	16238
	16239	export fn zig_ret_struct_u32_union_u32_u32u32() Struct_u32_Union_u32_u32u32 {
	16240	return .{ .a = 1, .b = .{ .c = .{ .d = 2, .e = 3 } } };
	16241	}
	16242	export fn zig_struct_u32_union_u32_u32u32(s: Struct_u32_Union_u32_u32u32) void {
	16243	expect(s.a == 1) catch @panic("test failure");
	16244	expect(s.b.c.d == 2) catch @panic("test failure");
	16245	expect(s.b.c.e == 3) catch @panic("test failure");
	16246	}
	16247
	16248	extern fn c_ret_struct_u32_union_u32_u32u32() Struct_u32_Union_u32_u32u32;
	16249	extern fn c_struct_u32_union_u32_u32u32(Struct_u32_Union_u32_u32u32) void;
	16250	extern fn c_test_struct_u32_union_u32_u32u32() void;
	16251
	16252	test "struct{u32,union{u32,struct{u32,u32}}}" {
	16253	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16254	if (builtin.cpu.arch == .loongarch64) return error.SkipZigTest;
	16255	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	16256	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	16257	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16258
	16259	const s = c_ret_struct_u32_union_u32_u32u32();
	16260	try expect(s.a == 1);
	16261	try expect(s.b.c.d == 2);
	16262	try expect(s.b.c.e == 3);
	16263	c_struct_u32_union_u32_u32u32(.{ .a = 1, .b = .{ .c = .{ .d = 2, .e = 3 } } });
	16264	c_test_struct_u32_union_u32_u32u32();
	16265	}
	16266
	16267	const Struct_i32_i32 = extern struct {
	16268	a: i32,
	16269	b: i32,
	16270	};
	16271	extern fn c_mut_struct_i32_i32(Struct_i32_i32) Struct_i32_i32;
	16272	extern fn c_struct_i32_i32(Struct_i32_i32) void;
	16273
	16274	test "struct i32 i32" {
	16275	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	16276	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	16277	if (builtin.cpu.arch.isRiscv32()) return error.SkipZigTest;
	16278	if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
	16279	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16280	if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
	16281
	16282	const s: Struct_i32_i32 = .{
	16283	.a = 1,
	16284	.b = 2,
	16285	};
	16286	const mut_res = c_mut_struct_i32_i32(s);
	16287	try expect(s.a == 1);
	16288	try expect(s.b == 2);
	16289	try expect(mut_res.a == 101);
	16290	try expect(mut_res.b == 252);
	16291	c_struct_i32_i32(s);
	16292	}
	16293
	16294	export fn zig_struct_i32_i32(s: Struct_i32_i32) void {
	16295	expect(s.a == 1) catch @panic("test failure: zig_struct_i32_i32 1");
	16296	expect(s.b == 2) catch @panic("test failure: zig_struct_i32_i32 2");
	16297	}
	16298
	16299	const BigStruct = extern struct {
	16300	a: u64,
	16301	b: u64,
	16302	c: u64,
	16303	d: u64,
	16304	e: u8,
	16305	};
	16306	extern fn c_big_struct(BigStruct) void;
	16307
	16308	test "big struct" {
	16309	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	16310	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	16311	if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
	16312	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16313	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16314
	16315	const s = BigStruct{
	16316	.a = 1,
	16317	.b = 2,
	16318	.c = 3,
	16319	.d = 4,
	16320	.e = 5,
	16321	};
	16322	c_big_struct(s);
	16323	}
	16324
	16325	export fn zig_big_struct(x: BigStruct) void {
	16326	expect(x.a == 1) catch @panic("test failure: zig_big_struct 1");
	16327	expect(x.b == 2) catch @panic("test failure: zig_big_struct 2");
	16328	expect(x.c == 3) catch @panic("test failure: zig_big_struct 3");
	16329	expect(x.d == 4) catch @panic("test failure: zig_big_struct 4");
	16330	expect(x.e == 5) catch @panic("test failure: zig_big_struct 5");
	16331	}
	16332
	16333	const BigUnion = extern union {
	16334	a: BigStruct,
	16335	};
	16336	extern fn c_big_union(BigUnion) void;
	16337
	16338	test "big union" {
	16339	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
	16340	if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
	16341	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16342	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16343
	16344	const x = BigUnion{
	16345	.a = BigStruct{
	16346	.a = 1,
	16347	.b = 2,
	16348	.c = 3,
	16349	.d = 4,
	16350	.e = 5,
	16351	},
	16352	};
	16353	c_big_union(x);
	16354	}
	16355
	16356	export fn zig_big_union(x: BigUnion) void {
	16357	expect(x.a.a == 1) catch @panic("test failure: zig_big_union a");
	16358	expect(x.a.b == 2) catch @panic("test failure: zig_big_union b");
	16359	expect(x.a.c == 3) catch @panic("test failure: zig_big_union c");
	16360	expect(x.a.d == 4) catch @panic("test failure: zig_big_union d");
	16361	expect(x.a.e == 5) catch @panic("test failure: zig_big_union e");
	16362	}
	16363
	16364	const MedStructMixed = extern struct {
	16365	a: u32,
	16366	b: f32,
	16367	c: f32,
	16368	d: u32 = 0,
	16369	};
	16370	extern fn c_med_struct_mixed(MedStructMixed) void;
	16371	extern fn c_ret_med_struct_mixed() MedStructMixed;
	16372
	16373	test "medium struct of ints and floats" {
	16374	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	16375	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	16376	if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
	16377	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16378	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16379
	16380	const s = MedStructMixed{
	16381	.a = 1234,
	16382	.b = 100.0,
	16383	.c = 1337.0,
	16384	};
	16385	c_med_struct_mixed(s);
	16386	const s2 = c_ret_med_struct_mixed();
	16387	try expect(s2.a == 1234);
	16388	try expect(s2.b == 100.0);
	16389	try expect(s2.c == 1337.0);
	16390	}
	16391
	16392	export fn zig_med_struct_mixed(x: MedStructMixed) void {
	16393	expect(x.a == 1234) catch @panic("test failure");
	16394	expect(x.b == 100.0) catch @panic("test failure");
	16395	expect(x.c == 1337.0) catch @panic("test failure");
	16396	}
	16397
	16398	const SmallPackedStruct = packed struct(u8) {
	16399	a: u2,
	16400	b: u2,
	16401	c: u2,
	16402	d: u2,
	16403	};
	16404	extern fn c_small_packed_struct(SmallPackedStruct) void;
	16405	extern fn c_ret_small_packed_struct() SmallPackedStruct;
	16406
	16407	export fn zig_small_packed_struct(x: SmallPackedStruct) void {
	16408	expect(x.a == 0) catch @panic("test failure");
	16409	expect(x.b == 1) catch @panic("test failure");
	16410	expect(x.c == 2) catch @panic("test failure");
	16411	expect(x.d == 3) catch @panic("test failure");
	16412	}
	16413
	16414	test "small packed struct" {
	16415	const s = SmallPackedStruct{ .a = 0, .b = 1, .c = 2, .d = 3 };
	16416	c_small_packed_struct(s);
	16417	const s2 = c_ret_small_packed_struct();
	16418	try expect(s2.a == 0);
	16419	try expect(s2.b == 1);
	16420	try expect(s2.c == 2);
	16421	try expect(s2.d == 3);
	16422	}
	16423
	16424	const BigPackedStruct = packed struct(u128) {
	16425	a: u64,
	16426	b: u64,
	16427	};
	16428	extern fn c_big_packed_struct(BigPackedStruct) void;
	16429	extern fn c_ret_big_packed_struct() BigPackedStruct;
	16430
	16431	export fn zig_big_packed_struct(x: BigPackedStruct) void {
	16432	expect(x.a == 1) catch @panic("test failure");
	16433	expect(x.b == 2) catch @panic("test failure");
	16434	}
	16435
	16436	test "big packed struct" {
	16437	if (!have_i128) return error.SkipZigTest;
	16438
	16439	const s = BigPackedStruct{ .a = 1, .b = 2 };
	16440	c_big_packed_struct(s);
	16441	const s2 = c_ret_big_packed_struct();
	16442	try expect(s2.a == 1);
	16443	try expect(s2.b == 2);
	16444	}
	16445
	16446	const SplitStructInt = extern struct {
	16447	a: u64,
	16448	b: u8,
	16449	c: u32,
	16450	};
	16451	extern fn c_split_struct_ints(SplitStructInt) void;
	16452
	16453	test "split struct of ints" {
	16454	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	16455	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	16456	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	16457	if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
	16458	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16459	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16460
	16461	const s = SplitStructInt{
	16462	.a = 1234,
	16463	.b = 100,
	16464	.c = 1337,
	16465	};
	16466	c_split_struct_ints(s);
	16467	}
	16468
	16469	export fn zig_split_struct_ints(x: SplitStructInt) void {
	16470	expect(x.a == 1234) catch @panic("test failure");
	16471	expect(x.b == 100) catch @panic("test failure");
	16472	expect(x.c == 1337) catch @panic("test failure");
	16473	}
	16474
	16475	const SplitStructMixed = extern struct {
	16476	a: u64,
	16477	b: u8,
	16478	c: f32,
	16479	};
	16480	extern fn c_split_struct_mixed(SplitStructMixed) void;
	16481	extern fn c_ret_split_struct_mixed() SplitStructMixed;
	16482
	16483	test "split struct of ints and floats" {
	16484	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	16485	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	16486	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	16487	if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
	16488	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16489	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16490
	16491	const s = SplitStructMixed{
	16492	.a = 1234,
	16493	.b = 100,
	16494	.c = 1337.0,
	16495	};
	16496	c_split_struct_mixed(s);
	16497	const s2 = c_ret_split_struct_mixed();
	16498	try expect(s2.a == 1234);
	16499	try expect(s2.b == 100);
	16500	try expect(s2.c == 1337.0);
	16501	}
	16502
	16503	export fn zig_split_struct_mixed(x: SplitStructMixed) void {
	16504	expect(x.a == 1234) catch @panic("test failure");
	16505	expect(x.b == 100) catch @panic("test failure");
	16506	expect(x.c == 1337.0) catch @panic("test failure");
	16507	}
	16508
	16509	extern fn c_big_struct_both(BigStruct) BigStruct;
	16510
	16511	test "sret and byval together" {
	16512	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	16513	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	16514	if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
	16515	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16516	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16517
	16518	const s = BigStruct{
	16519	.a = 1,
	16520	.b = 2,
	16521	.c = 3,
	16522	.d = 4,
	16523	.e = 5,
	16524	};
	16525	const y = c_big_struct_both(s);
	16526	try expect(y.a == 10);
	16527	try expect(y.b == 11);
	16528	try expect(y.c == 12);
	16529	try expect(y.d == 13);
	16530	try expect(y.e == 14);
	16531	}
	16532
	16533	export fn zig_big_struct_both(x: BigStruct) BigStruct {
	16534	expect(x.a == 30) catch @panic("test failure");
	16535	expect(x.b == 31) catch @panic("test failure");
	16536	expect(x.c == 32) catch @panic("test failure");
	16537	expect(x.d == 33) catch @panic("test failure");
	16538	expect(x.e == 34) catch @panic("test failure");
	16539	const s = BigStruct{
	16540	.a = 20,
	16541	.b = 21,
	16542	.c = 22,
	16543	.d = 23,
	16544	.e = 24,
	16545	};
	16546	return s;
	16547	}
	16548
	16549	export fn zig_ret_bool() bool {
	16550	return true;
	16551	}
	16552	export fn zig_ret_u8() u8 {
	16553	return 0xff;
	16554	}
	16555	export fn zig_ret_u16() u16 {
	16556	return 0xffff;
	16557	}
	16558	export fn zig_ret_u32() u32 {
	16559	return 0xffffffff;
	16560	}
	16561	export fn zig_ret_u64() u64 {
	16562	return 0xffffffffffffffff;
	16563	}
	16564	export fn zig_ret_i8() i8 {
	16565	return -1;
	16566	}
	16567	export fn zig_ret_i16() i16 {
	16568	return -1;
	16569	}
	16570	export fn zig_ret_i32() i32 {
	16571	return -1;
	16572	}
	16573	export fn zig_ret_i64() i64 {
	16574	return -1;
	16575	}
	16576
	16577	export fn zig_ret_med_struct_mixed() MedStructMixed {
	16578	return .{
	16579	.a = 1234,
	16580	.b = 100.0,
	16581	.c = 1337.0,
	16582	};
	16583	}
	16584
	16585	export fn zig_ret_split_struct_mixed() SplitStructMixed {
	16586	return .{
	16587	.a = 1234,
	16588	.b = 100,
	16589	.c = 1337.0,
	16590	};
	16591	}
	16592
	16593	extern fn c_ret_bool() bool;
	16594	extern fn c_ret_u8() u8;
	16595	extern fn c_ret_u16() u16;
	16596	extern fn c_ret_u32() u32;
	16597	extern fn c_ret_u64() u64;
	16598	extern fn c_ret_i8() i8;
	16599	extern fn c_ret_i16() i16;
	16600	extern fn c_ret_i32() i32;
	16601	extern fn c_ret_i64() i64;
	16602
	16603	test "integer return types" {
	16604	try expect(c_ret_bool() == true);
	16605
	16606	try expect(c_ret_u8() == 0xff);
	16607	try expect(c_ret_u16() == 0xffff);
	16608	try expect(c_ret_u32() == 0xffffffff);
	16609	try expect(c_ret_u64() == 0xffffffffffffffff);
	16610
	16611	try expect(c_ret_i8() == -1);
	16612	try expect(c_ret_i16() == -1);
	16613	try expect(c_ret_i32() == -1);
	16614	try expect(c_ret_i64() == -1);
	16615	}
	16616
	16617	const StructWithArray = extern struct {
	16618	a: i32,
	16619	padding: [4]u8,
	16620	b: i64,
	16621	};
	16622	extern fn c_struct_with_array(StructWithArray) void;
	16623	extern fn c_ret_struct_with_array() StructWithArray;
	16624
	16625	test "Struct with array as padding." {
	16626	if (builtin.cpu.arch == .x86) return error.SkipZigTest;
	16627	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
	16628	if (builtin.cpu.arch.isPowerPC()) return error.SkipZigTest;
	16629	if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
	16630	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
	16631	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
	16632
	16633	c_struct_with_array(.{ .a = 1, .padding = undefined, .b = 2 });
	16634
	16635	const x = c_ret_struct_with_array();
	16636	try expect(x.a == 4);
	16637	try expect(x.b == 155);
	16638	}
	16639
	16640	const FloatArrayStruct = extern struct {
	16641	origin: extern struct {
	16642	x: f64,
	16643	y: f64,
	16644	},
	16645	size: extern struct {
	16646	width: f64,
	16647	height: f64,
	16648	},
	16649	};
5681	16650
5682		extern fn c_ptr_size_float_struct(Vector2) void;
5683		extern fn c_ret_ptr_size_float_struct() Vector2;
	16651	extern fn c_float_array_struct(FloatArrayStruct) void;
	16652	extern fn c_ret_float_array_struct() FloatArrayStruct;
5684	16653
5685		test "C ABI pointer sized float struct" {
	16654	test "Float array like struct" {
5686	16655	if (builtin.cpu.arch.isMIPS64()) return error.SkipZigTest;
5687	16656	if (builtin.cpu.arch.isPowerPC32()) return error.SkipZigTest;
5688		if (builtin.cpu.arch.isArm() and builtin.abi.float() == .soft) return error.SkipZigTest;
5689		if (builtin.cpu.arch.isLoongArch() and builtin.abi.float() == .soft) return error.SkipZigTest;
	16657	if (builtin.cpu.arch.isLoongArch()) return error.SkipZigTest;
	16658	if (builtin.cpu.arch == .hexagon) return error.SkipZigTest;
5690	16659	if (builtin.cpu.arch == .s390x) return error.SkipZigTest;
5691		if (builtin.cpu.arch == .x86 and builtin.os.tag == .windows) return error.SkipZigTest;
5692	16660
5693		c_ptr_size_float_struct(.{ .x = 1, .y = 2 });
	16661	c_float_array_struct(.{
	16662	.origin = .{
	16663	.x = 5,
	16664	.y = 6,
	16665	},
	16666	.size = .{
	16667	.width = 7,
	16668	.height = 8,
	16669	},
	16670	});
5694	16671
5695		const x = c_ret_ptr_size_float_struct();
5696		try expect(x.x == 3);
5697		try expect(x.y == 4);
	16672	const x = c_ret_float_array_struct();
	16673	try expect(x.origin.x == 1);
	16674	try expect(x.origin.y == 2);
	16675	try expect(x.size.width == 3);
	16676	try expect(x.size.height == 4);
5698	16677	}
5699	16678
5700	16679	//=== Helpers for struct test ===//

test/tests.zig+31

...	...	@@ -2018,12 +2018,43 @@ const c_abi_targets = blk: {
2018	2018	.abi = .gnu,
2019	2019	},
2020	2020	},
	2021
	2022	//.{
	2023	// .target = .{
	2024	// .cpu_arch = .x86_64,
	2025	// .os_tag = .windows,
	2026	// .abi = .gnu,
	2027	// },
	2028	// .use_llvm = false,
	2029	// .c_defines = &.{"ZIG_BACKEND_STAGE2_X86_64"},
	2030	//},
	2031	//.{
	2032	// .target = .{
	2033	// .cpu_arch = .x86_64,
	2034	// .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64_v2 },
	2035	// .os_tag = .windows,
	2036	// .abi = .gnu,
	2037	// },
	2038	// .use_llvm = false,
	2039	// .c_defines = &.{"ZIG_BACKEND_STAGE2_X86_64"},
	2040	//},
	2041	//.{
	2042	// .target = .{
	2043	// .cpu_arch = .x86_64,
	2044	// .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64_v3 },
	2045	// .os_tag = .windows,
	2046	// .abi = .gnu,
	2047	// },
	2048	// .use_llvm = false,
	2049	// .c_defines = &.{"ZIG_BACKEND_STAGE2_X86_64"},
	2050	//},
2021	2051	.{
2022	2052	.target = .{
2023	2053	.cpu_arch = .x86_64,
2024	2054	.os_tag = .windows,
2025	2055	.abi = .gnu,
2026	2056	},
	2057	.use_llvm = true,
2027	2058	},
2028	2059	};
2029	2060	};